feat: Passwordless cross-device authentication

- Arkitektur: docs/auth/passwordless-architecture.md
- Backend: iom/quixzoom-auth-service/ (FastAPI + Redis)
- Webb: quixzoom-market-pages/se/login/ (QR-kod + polling)
- App: iom/quixzoom-app/src/features/auth/ (push + deep links)

Flöde: QR-kod → app-godkännande → webb-inloggad

landvex-report-system/node_modules/@redis/time-series/README.md

@@ -0,0 +1,167 @@
+# @redis/time-series
+
+This package provides support for the [RedisTimeSeries](https://redis.io/docs/data-types/timeseries/) module, which adds a time series data structure to Redis.
+
+Should be used with [`redis`/`@redis/client`](https://github.com/redis/node-redis).
+
+:warning: To use these extra commands, your Redis server must have the RedisTimeSeries module installed.
+
+## Usage
+
+For a complete example, see [`time-series.js`](https://github.com/redis/node-redis/blob/master/examples/time-series.js) in the Node Redis examples folder.
+
+### Creating Time Series data structure in Redis
+
+The [`TS.CREATE`](https://oss.redis.com/redistimeseries/commands/#tscreate) command creates a new time series.
+
+Here, we'll create a new time series "`temperature`":
+
+```javascript
+
+import { createClient } from 'redis';
+import { TimeSeriesDuplicatePolicies, TimeSeriesEncoding, TIME_SERIES_AGGREGATION_TYPE } from '@redis/time-series';
+
+...
+const created = await client.ts.create('temperature', {
+  RETENTION: 86400000, // 1 day in milliseconds
+  ENCODING: TimeSeriesEncoding.UNCOMPRESSED, // No compression - When not specified, the option is set to COMPRESSED
+  DUPLICATE_POLICY: TimeSeriesDuplicatePolicies.BLOCK, // No duplicates - When not specified: set to the global DUPLICATE_POLICY configuration of the database (which by default, is BLOCK).
+});
+
+if (created === 'OK') {
+  console.log('Created timeseries.');
+} else {
+  console.log('Error creating timeseries :(');
+  process.exit(1);
+}
+```
+
+### Adding new value to a Time Series data structure in Redis
+
+With RedisTimeSeries, we can add a single value to time series data structure using the [`TS.ADD`](https://redis.io/commands/ts.add/) command and if we would like to add multiple values we can use the [`TS.MADD`](https://redis.io/commands/ts.madd/) command.
+
+```javascript
+
+let value = Math.floor(Math.random() * 1000) + 1; // Random data point value
+let currentTimestamp = 1640995200000; // Jan 1 2022 00:00:00
+let num = 0;
+
+while (num < 10000) {
+  // Add a new value to the timeseries, providing our own timestamp:
+  // https://redis.io/commands/ts.add/
+  await client.ts.add('temperature', currentTimestamp, value);
+  console.log(`Added timestamp ${currentTimestamp}, value ${value}.`);
+
+  num += 1;
+  value = Math.floor(Math.random() * 1000) + 1; // Get another random value
+  currentTimestamp += 1000; // Move on one second.
+}
+
+// Add multiple values to the timeseries in round trip to the server:
+// https://redis.io/commands/ts.madd/
+const response = await client.ts.mAdd([{
+  key: 'temperature',
+  timestamp: currentTimestamp + 60000,
+  value: Math.floor(Math.random() * 1000) + 1
+}, {
+  key: 'temperature',
+  timestamp: currentTimestamp + 120000,
+  value: Math.floor(Math.random() * 1000) + 1
+}]);
+```
+
+### Retrieving Time Series data from Redis
+
+With RedisTimeSeries, we can retrieve the time series data using the [`TS.RANGE`](https://redis.io/commands/ts.range/) command by passing the criteria as follows:
+
+```javascript
+// Query the timeseries with TS.RANGE:
+// https://redis.io/commands/ts.range/
+const fromTimestamp = 1640995200000; // Jan 1 2022 00:00:00
+const toTimestamp = 1640995260000; // Jan 1 2022 00:01:00
+const rangeResponse = await client.ts.range('temperature', fromTimestamp, toTimestamp, {
+  // Group into 10 second averages.
+  AGGREGATION: {
+    type: TIME_SERIES_AGGREGATION_TYPE.AVG,
+    timeBucket: 10000
+  }
+});
+
+console.log('RANGE RESPONSE:');
+// rangeResponse looks like:
+// [
+//   { timestamp: 1640995200000, value: 356.8 },
+//   { timestamp: 1640995210000, value: 534.8 },
+//   { timestamp: 1640995220000, value: 481.3 },
+//   { timestamp: 1640995230000, value: 437 },
+//   { timestamp: 1640995240000, value: 507.3 },
+//   { timestamp: 1640995250000, value: 581.2 },
+//   { timestamp: 1640995260000, value: 600 }
+// ]
+```
+
+For multiple aggregations in one command, use the dedicated `*MultiAggr` methods:
+
+```javascript
+const multiRangeResponse = await client.ts.rangeMultiAggr('temperature', fromTimestamp, toTimestamp, {
+  AGGREGATION: {
+    types: [
+      TIME_SERIES_AGGREGATION_TYPE.MIN,
+      TIME_SERIES_AGGREGATION_TYPE.MAX,
+      TIME_SERIES_AGGREGATION_TYPE.AVG
+    ],
+    timeBucket: 10000
+  }
+});
+
+// multiRangeResponse looks like:
+// [
+//   { timestamp: 1640995200000, values: [120, 580, 356.8] },
+//   ...
+// ]
+```
+
+Equivalent multi-aggregation helpers are also available for reverse and multi-key variants:
+`revRangeMultiAggr`, `mRangeMultiAggr`, `mRevRangeMultiAggr`, `mRangeWithLabelsMultiAggr`,
+`mRevRangeWithLabelsMultiAggr`, `mRangeSelectedLabelsMultiAggr`, and `mRevRangeSelectedLabelsMultiAggr`.
+
+### Altering Time Series data Stored in Redis
+
+RedisTimeSeries includes commands that can update values in a time series data structure.
+
+Using the [`TS.ALTER`](https://redis.io/commands/ts.alter/) command, we can update time series retention like this:
+
+```javascript
+// https://redis.io/commands/ts.alter/
+const alterResponse = await client.ts.alter('temperature', {
+  RETENTION: 0 // Keep the entries forever
+});
+```
+
+### Retrieving Information about the timeseries Stored in Redis
+
+RedisTimeSeries also includes commands that can help to view the information on the state of a time series.
+
+Using the [`TS.INFO`](https://redis.io/commands/ts.info/) command, we can view timeseries information like this:
+
+```javascript
+// Get some information about the state of the timeseries.
+// https://redis.io/commands/ts.info/
+const tsInfo = await client.ts.info('temperature');
+
+// tsInfo looks like this:
+// {
+//   totalSamples: 1440,
+//   memoryUsage: 28904,
+//   firstTimestamp: 1641508920000,
+//   lastTimestamp: 1641595320000,
+//   retentionTime: 86400000,
+//   chunkCount: 7,
+//   chunkSize: 4096,
+//   chunkType: 'uncompressed',
+//   duplicatePolicy: 'block',
+//   labels: [],
+//   sourceKey: null,
+//   rules: []
+// }
+```

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ADD.d.ts

@@ -0,0 +1,22 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+import { TimeSeriesEncoding, TimeSeriesDuplicatePolicies, Labels, Timestamp } from './helpers';
+export interface TsIgnoreOptions {
+    maxTimeDiff: number;
+    maxValDiff: number;
+}
+export interface TsAddOptions {
+    RETENTION?: number;
+    ENCODING?: TimeSeriesEncoding;
+    CHUNK_SIZE?: number;
+    ON_DUPLICATE?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+    IGNORE?: TsIgnoreOptions;
+}
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, timestamp: Timestamp, value: number, options?: TsAddOptions) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=ADD.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ADD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ADD.d.ts","sourceRoot":"","sources":["../../../lib/commands/ADD.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAGL,kBAAkB,EAGlB,2BAA2B,EAC3B,MAAM,EAEN,SAAS,EAEV,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,2BAA2B,CAAC;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;;;gDAKW,aAAa,OAChB,aAAa,aACP,SAAS,SACb,MAAM,YACH,YAAY;mCAoBsB,WAAW;;AA3B3D,wBA4B6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ADD.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ADD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ADD.js","sourceRoot":"","sources":["../../../lib/commands/ADD.ts"],"names":[],"mappings":";;AAEA,uCAWmB;AAgBnB,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CACV,MAAqB,EACrB,GAAkB,EAClB,SAAoB,EACpB,KAAa,EACb,OAAsB;QAEtB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,IAAA,oCAA0B,EAAC,SAAS,CAAC,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAErE,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAEnD,IAAA,+BAAqB,EAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAEjD,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAEpD,IAAI,OAAO,EAAE,YAAY,EAAE,CAAC;YAC1B,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;QACpD,CAAC;QAED,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAE7C,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport {\n  transformTimestampArgument,\n  parseRetentionArgument,\n  TimeSeriesEncoding,\n  parseEncodingArgument,\n  parseChunkSizeArgument,\n  TimeSeriesDuplicatePolicies,\n  Labels,\n  parseLabelsArgument,\n  Timestamp,\n  parseIgnoreArgument\n} from './helpers';\n\nexport interface TsIgnoreOptions {\n  maxTimeDiff: number;\n  maxValDiff: number;\n}\n\nexport interface TsAddOptions {\n  RETENTION?: number;\n  ENCODING?: TimeSeriesEncoding;\n  CHUNK_SIZE?: number;\n  ON_DUPLICATE?: TimeSeriesDuplicatePolicies;\n  LABELS?: Labels;\n  IGNORE?: TsIgnoreOptions;\n}\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(\n    parser: CommandParser,\n    key: RedisArgument,\n    timestamp: Timestamp,\n    value: number,\n    options?: TsAddOptions\n  ) {\n    parser.push('TS.ADD');\n    parser.pushKey(key);\n    parser.push(transformTimestampArgument(timestamp), value.toString());\n\n    parseRetentionArgument(parser, options?.RETENTION);\n\n    parseEncodingArgument(parser, options?.ENCODING);\n\n    parseChunkSizeArgument(parser, options?.CHUNK_SIZE);\n\n    if (options?.ON_DUPLICATE) {\n      parser.push('ON_DUPLICATE', options.ON_DUPLICATE);\n    }\n\n    parseLabelsArgument(parser, options?.LABELS);\n\n    parseIgnoreArgument(parser, options?.IGNORE);\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ALTER.d.ts

@@ -0,0 +1,11 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { TsCreateOptions } from './CREATE';
+export type TsAlterOptions = Pick<TsCreateOptions, 'RETENTION' | 'CHUNK_SIZE' | 'DUPLICATE_POLICY' | 'LABELS' | 'IGNORE'>;
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, options?: TsAlterOptions) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=ALTER.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ALTER.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALTER.d.ts","sourceRoot":"","sources":["../../../lib/commands/ALTER.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;AAC9F,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI3C,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,eAAe,EAAE,WAAW,GAAG,YAAY,GAAG,kBAAkB,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAC;;;gDAInG,aAAa,OAAO,aAAa,YAAY,cAAc;mCAclC,kBAAkB,IAAI,CAAC;;AAhBvE,wBAiB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ALTER.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/ALTER.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ALTER.js","sourceRoot":"","sources":["../../../lib/commands/ALTER.ts"],"names":[],"mappings":";;AAGA,uCAA2I;AAK3I,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,OAAwB;QAC9E,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACxB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAEpB,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAEnD,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAEpD,IAAA,8BAAoB,EAAC,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAExD,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAE7C,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { TsCreateOptions } from './CREATE';\nimport { parseRetentionArgument, parseChunkSizeArgument, parseDuplicatePolicy, parseLabelsArgument, parseIgnoreArgument } from './helpers';\n\n\nexport type TsAlterOptions = Pick<TsCreateOptions, 'RETENTION' | 'CHUNK_SIZE' | 'DUPLICATE_POLICY' | 'LABELS' | 'IGNORE'>;\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(parser: CommandParser, key: RedisArgument, options?: TsAlterOptions) {\n    parser.push('TS.ALTER');\n    parser.pushKey(key);\n\n    parseRetentionArgument(parser, options?.RETENTION);\n\n    parseChunkSizeArgument(parser, options?.CHUNK_SIZE);\n\n    parseDuplicatePolicy(parser, options?.DUPLICATE_POLICY);\n\n    parseLabelsArgument(parser, options?.LABELS);\n\n    parseIgnoreArgument(parser, options?.IGNORE);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATE.d.ts

@@ -0,0 +1,19 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { TimeSeriesEncoding, TimeSeriesDuplicatePolicies, Labels } from './helpers';
+import { TsIgnoreOptions } from './ADD';
+export interface TsCreateOptions {
+    RETENTION?: number;
+    ENCODING?: TimeSeriesEncoding;
+    CHUNK_SIZE?: number;
+    DUPLICATE_POLICY?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+    IGNORE?: TsIgnoreOptions;
+}
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, options?: TsCreateOptions) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=CREATE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CREATE.d.ts","sourceRoot":"","sources":["../../../lib/commands/CREATE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;AAC9F,OAAO,EAEL,kBAAkB,EAGlB,2BAA2B,EAE3B,MAAM,EAGP,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAExC,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,2BAA2B,CAAC;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;;;gDAIsB,aAAa,OAAO,aAAa,YAAY,eAAe;mCAgBnC,kBAAkB,IAAI,CAAC;;AAlBvE,wBAmB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATE.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CREATE.js","sourceRoot":"","sources":["../../../lib/commands/CREATE.ts"],"names":[],"mappings":";;AAEA,uCAUmB;AAYnB,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,OAAyB;QAC/E,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAEpB,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAEnD,IAAA,+BAAqB,EAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QAEjD,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAEpD,IAAA,8BAAoB,EAAC,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAExD,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAE7C,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport {\n  parseRetentionArgument,\n  TimeSeriesEncoding,\n  parseEncodingArgument,\n  parseChunkSizeArgument,\n  TimeSeriesDuplicatePolicies,\n  parseDuplicatePolicy,\n  Labels,\n  parseLabelsArgument,\n  parseIgnoreArgument\n} from './helpers';\nimport { TsIgnoreOptions } from './ADD';\n\nexport interface TsCreateOptions {\n  RETENTION?: number;\n  ENCODING?: TimeSeriesEncoding;\n  CHUNK_SIZE?: number;\n  DUPLICATE_POLICY?: TimeSeriesDuplicatePolicies;\n  LABELS?: Labels;\n  IGNORE?: TsIgnoreOptions;\n}\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(parser: CommandParser, key: RedisArgument, options?: TsCreateOptions) {\n    parser.push('TS.CREATE');\n    parser.pushKey(key);\n\n    parseRetentionArgument(parser, options?.RETENTION);\n\n    parseEncodingArgument(parser, options?.ENCODING);\n\n    parseChunkSizeArgument(parser, options?.CHUNK_SIZE);\n\n    parseDuplicatePolicy(parser, options?.DUPLICATE_POLICY);\n\n    parseLabelsArgument(parser, options?.LABELS);\n\n    parseIgnoreArgument(parser, options?.IGNORE);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATERULE.d.ts

@@ -0,0 +1,33 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+export declare const TIME_SERIES_AGGREGATION_TYPE: {
+    readonly AVG: "AVG";
+    readonly FIRST: "FIRST";
+    readonly LAST: "LAST";
+    readonly MIN: "MIN";
+    readonly MAX: "MAX";
+    readonly SUM: "SUM";
+    readonly RANGE: "RANGE";
+    readonly COUNT: "COUNT";
+    /**
+    * Available since 8.6
+    */
+    readonly COUNT_NAN: "COUNTNAN";
+    /**
+    * Available since 8.6
+    */
+    readonly COUNT_ALL: "COUNTALL";
+    readonly STD_P: "STD.P";
+    readonly STD_S: "STD.S";
+    readonly VAR_P: "VAR.P";
+    readonly VAR_S: "VAR.S";
+    readonly TWA: "TWA";
+};
+export type TimeSeriesAggregationType = typeof TIME_SERIES_AGGREGATION_TYPE[keyof typeof TIME_SERIES_AGGREGATION_TYPE];
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, sourceKey: RedisArgument, destinationKey: RedisArgument, aggregationType: TimeSeriesAggregationType, bucketDuration: number, alignTimestamp?: number) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=CREATERULE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATERULE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CREATERULE.d.ts","sourceRoot":"","sources":["../../../lib/commands/CREATERULE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;AAE9F,eAAO,MAAM,4BAA4B;;;;;;;;;IASvC;;MAEE;;IAEF;;MAEE;;;;;;;CAOM,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,OAAO,4BAA4B,CAAC,MAAM,OAAO,4BAA4B,CAAC,CAAC;;;gDAK3G,aAAa,aACV,aAAa,kBACR,aAAa,mBACZ,yBAAyB,kBAC1B,MAAM,mBACL,MAAM;mCAUqB,kBAAkB,IAAI,CAAC;;AAlBvE,wBAmB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATERULE.js

@@ -0,0 +1,39 @@
+"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,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/CREATERULE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CREATERULE.js","sourceRoot":"","sources":["../../../lib/commands/CREATERULE.ts"],"names":[],"mappings":";;;AAGa,QAAA,4BAA4B,GAAG;IAC1C,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd;;MAEE;IACF,SAAS,EAAE,UAAU;IACrB;;MAEE;IACF,SAAS,EAAE,UAAU;IACrB,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;CACF,CAAC;AAIX,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CACV,MAAqB,EACrB,SAAwB,EACxB,cAA6B,EAC7B,eAA0C,EAC1C,cAAsB,EACtB,cAAuB;QAEvB,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC7B,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,eAAe,EAAE,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEvE,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport const TIME_SERIES_AGGREGATION_TYPE = {\n  AVG: 'AVG',\n  FIRST: 'FIRST',\n  LAST: 'LAST',\n  MIN: 'MIN',\n  MAX: 'MAX',\n  SUM: 'SUM',\n  RANGE: 'RANGE',\n  COUNT: 'COUNT',\n  /**\n  * Available since 8.6\n  */\n  COUNT_NAN: 'COUNTNAN',\n  /**\n  * Available since 8.6\n  */\n  COUNT_ALL: 'COUNTALL',\n  STD_P: 'STD.P',\n  STD_S: 'STD.S',\n  VAR_P: 'VAR.P',\n  VAR_S: 'VAR.S',\n  TWA: 'TWA'\n} as const;\n\nexport type TimeSeriesAggregationType = typeof TIME_SERIES_AGGREGATION_TYPE[keyof typeof TIME_SERIES_AGGREGATION_TYPE];\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(\n    parser: CommandParser,\n    sourceKey: RedisArgument,\n    destinationKey: RedisArgument,\n    aggregationType: TimeSeriesAggregationType,\n    bucketDuration: number,\n    alignTimestamp?: number\n  ) {\n    parser.push('TS.CREATERULE');\n    parser.pushKeys([sourceKey, destinationKey]);\n    parser.push('AGGREGATION', aggregationType, bucketDuration.toString());\n\n    if (alignTimestamp !== undefined) {\n      parser.push(alignTimestamp.toString());\n    }\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DECRBY.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, value: number, options?: import("./INCRBY").TsIncrByOptions | undefined) => void;
+    readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+};
+export default _default;
+//# sourceMappingURL=DECRBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DECRBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DECRBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/DECRBY.ts"],"names":[],"mappings":";;;;;AAGA,wBAS6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DECRBY.js

@@ -0,0 +1,36 @@
+"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,
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.DECRBY');
+        (0, INCRBY_1.parseIncrByArguments)(...args);
+    },
+    transformReply: INCRBY_1.default.transformReply
+};
+//# sourceMappingURL=DECRBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DECRBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DECRBY.js","sourceRoot":"","sources":["../../../lib/commands/DECRBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,mDAAwD;AAExD,kBAAe;IACb,YAAY,EAAE,gBAAM,CAAC,YAAY;IACjC,YAAY,CAAC,GAAG,IAA6C;QAC3D,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzB,IAAA,6BAAoB,EAAC,GAAG,IAAI,CAAC,CAAC;IAChC,CAAC;IACD,cAAc,EAAE,gBAAM,CAAC,cAAc;CACX,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport INCRBY, { parseIncrByArguments } from './INCRBY';\n\nexport default {\n  IS_READ_ONLY: INCRBY.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof parseIncrByArguments>) {\n    const parser = args[0];\n\n    parser.push('TS.DECRBY');\n    parseIncrByArguments(...args);\n  },\n  transformReply: INCRBY.transformReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DEL.d.ts

@@ -0,0 +1,10 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { Timestamp } from './helpers';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=DEL.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DEL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEL.d.ts","sourceRoot":"","sources":["../../../lib/commands/DEL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,SAAS,EAA8B,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAY,MAAM,mCAAmC,CAAC;;;gDAIlE,aAAa,OAAO,aAAa,iBAAiB,SAAS,eAAe,SAAS;mCAK1D,WAAW;;AAP3D,wBAQ6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DEL.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DEL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DEL.js","sourceRoot":"","sources":["../../../lib/commands/DEL.ts"],"names":[],"mappings":";;AACA,uCAAkE;AAGlE,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,aAAwB,EAAE,WAAsB;QACtG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACpB,MAAM,CAAC,IAAI,CAAC,IAAA,oCAA0B,EAAC,aAAa,CAAC,EAAE,IAAA,oCAA0B,EAAC,WAAW,CAAC,CAAC,CAAC;IAClG,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Timestamp, transformTimestampArgument } from './helpers';\nimport { RedisArgument, NumberReply, Command, } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(parser: CommandParser, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp) {\n    parser.push('TS.DEL');\n    parser.pushKey(key);\n    parser.push(transformTimestampArgument(fromTimestamp), transformTimestampArgument(toTimestamp));\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DELETERULE.d.ts

@@ -0,0 +1,9 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, sourceKey: RedisArgument, destinationKey: RedisArgument) => void;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;
+//# sourceMappingURL=DELETERULE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DELETERULE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DELETERULE.d.ts","sourceRoot":"","sources":["../../../lib/commands/DELETERULE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAW,MAAM,mCAAmC,CAAC;;;gDAIvE,aAAa,aAAa,aAAa,kBAAkB,aAAa;mCAI7C,kBAAkB,IAAI,CAAC;;AANvE,wBAO6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DELETERULE.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: false,
+    parseCommand(parser, sourceKey, destinationKey) {
+        parser.push('TS.DELETERULE');
+        parser.pushKeys([sourceKey, destinationKey]);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DELETERULE.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/DELETERULE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DELETERULE.js","sourceRoot":"","sources":["../../../lib/commands/DELETERULE.ts"],"names":[],"mappings":";;AAGA,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CAAC,MAAqB,EAAE,SAAwB,EAAE,cAA6B;QACzF,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC7B,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;IAC/C,CAAC;IACD,cAAc,EAAE,SAAqD;CAC3C,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(parser: CommandParser, sourceKey: RedisArgument, destinationKey: RedisArgument) {\n    parser.push('TS.DELETERULE');\n    parser.pushKeys([sourceKey, destinationKey]);\n  },\n  transformReply: undefined as unknown as () => SimpleStringReply<'OK'>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/GET.d.ts

@@ -0,0 +1,22 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, TuplesReply, NumberReply, DoubleReply, UnwrapReply, Resp2Reply } from '@redis/client/dist/lib/RESP/types';
+export interface TsGetOptions {
+    LATEST?: boolean;
+}
+export type TsGetReply = TuplesReply<[]> | TuplesReply<[NumberReply, DoubleReply]>;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, options?: TsGetOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: UnwrapReply<Resp2Reply<TsGetReply>>) => {
+            timestamp: NumberReply<number>;
+            value: number;
+        } | null;
+        readonly 3: (this: void, reply: UnwrapReply<TsGetReply>) => {
+            timestamp: NumberReply<number>;
+            value: DoubleReply<number>;
+        } | null;
+    };
+};
+export default _default;
+//# sourceMappingURL=GET.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/GET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GET.d.ts","sourceRoot":"","sources":["../../../lib/commands/GET.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAW,MAAM,mCAAmC,CAAC;AAE3I,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;;;gDAI5D,aAAa,OAAO,aAAa,YAAY,YAAY;;wCASnE,YAAY,WAAW,UAAU,CAAC,CAAC;;;;wCAMnC,YAAY,UAAU,CAAC;;;;;;AAjBpC,wBAwB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/GET.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/GET.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GET.js","sourceRoot":"","sources":["../../../lib/commands/GET.ts"],"names":[],"mappings":";;AASA,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,GAAkB,EAAE,OAAsB;QAC5E,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAEpB,IAAI,OAAO,EAAE,MAAM,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IACD,cAAc,EAAE;QACd,CAAC,CAAC,KAA0C;YAC1C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;gBACjC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACnB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;aACxB,CAAC;QACJ,CAAC;QACD,CAAC,CAAC,KAA8B;YAC9B,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;gBACjC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACnB,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;aAChB,CAAC;QACJ,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, TuplesReply, NumberReply, DoubleReply, UnwrapReply, Resp2Reply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport interface TsGetOptions {\n  LATEST?: boolean;\n}\n\nexport type TsGetReply = TuplesReply<[]> | TuplesReply<[NumberReply, DoubleReply]>;\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, key: RedisArgument, options?: TsGetOptions) {\n    parser.push('TS.GET');\n    parser.pushKey(key);\n    \n    if (options?.LATEST) {\n      parser.push('LATEST');\n    }\n  },\n  transformReply: {\n    2(reply: UnwrapReply<Resp2Reply<TsGetReply>>) {\n      return reply.length === 0 ? null : {\n        timestamp: reply[0],\n        value: Number(reply[1])\n      };\n    },\n    3(reply: UnwrapReply<TsGetReply>) {\n      return reply.length === 0 ? null : {\n        timestamp: reply[0],\n        value: reply[1]\n      };\n    }\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INCRBY.d.ts

@@ -0,0 +1,27 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+import { Timestamp, Labels } from './helpers';
+import { TsIgnoreOptions } from './ADD';
+export interface TsIncrByOptions {
+    TIMESTAMP?: Timestamp;
+    RETENTION?: number;
+    UNCOMPRESSED?: boolean;
+    CHUNK_SIZE?: number;
+    LABELS?: Labels;
+    IGNORE?: TsIgnoreOptions;
+}
+/**
+ * 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
+ */
+export declare function parseIncrByArguments(parser: CommandParser, key: RedisArgument, value: number, options?: TsIncrByOptions): void;
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, value: number, options?: TsIncrByOptions | undefined) => void;
+    readonly transformReply: () => NumberReply;
+};
+export default _default;
+//# sourceMappingURL=INCRBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INCRBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"INCRBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/INCRBY.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAW,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,SAAS,EAA8E,MAAM,EAA4C,MAAM,WAAW,CAAC;AACpK,OAAO,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AAExC,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,QAoB1B;;;;mCAU+C,WAAW;;AAR3D,wBAS6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INCRBY.js

@@ -0,0 +1,36 @@
+"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,
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.INCRBY');
+        parseIncrByArguments(...args);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=INCRBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INCRBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"INCRBY.js","sourceRoot":"","sources":["../../../lib/commands/INCRBY.ts"],"names":[],"mappings":";;;AAEA,uCAAoK;AAYpK;;;;;;GAMG;AACH,SAAgB,oBAAoB,CAClC,MAAqB,EACrB,GAAkB,EAClB,KAAa,EACb,OAAyB;IAEzB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACpB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IAE9B,IAAI,OAAO,EAAE,SAAS,KAAK,SAAS,IAAI,OAAO,EAAE,SAAS,KAAK,IAAI,EAAE,CAAC;QACpE,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,IAAA,oCAA0B,EAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;IAC1E,CAAC;IAED,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IAEnD,IAAI,OAAO,EAAE,YAAY,EAAE,CAAC;QAC1B,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC9B,CAAC;IAED,IAAA,gCAAsB,EAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAEpD,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAE7C,IAAA,6BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AAC/C,CAAC;AAxBD,oDAwBC;AAED,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CAAC,GAAG,IAA6C;QAC3D,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzB,oBAAoB,CAAC,GAAG,IAAI,CAAC,CAAC;IAChC,CAAC;IACD,cAAc,EAAE,SAAyC;CAC/B,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { Timestamp, transformTimestampArgument, parseRetentionArgument, parseChunkSizeArgument, Labels, parseLabelsArgument, parseIgnoreArgument } from './helpers';\nimport { TsIgnoreOptions } from './ADD';\n\nexport interface TsIncrByOptions {\n  TIMESTAMP?: Timestamp;\n  RETENTION?: number;\n  UNCOMPRESSED?: boolean;\n  CHUNK_SIZE?: number;\n  LABELS?: Labels;\n  IGNORE?: TsIgnoreOptions;\n}\n\n/**\n * Parses arguments for incrementing a time series value\n * @param parser - The command parser\n * @param key - The key name of the time series\n * @param value - The value to increment by\n * @param options - Optional parameters for the command\n */\nexport function parseIncrByArguments(\n  parser: CommandParser,\n  key: RedisArgument,\n  value: number,\n  options?: TsIncrByOptions\n) {\n  parser.pushKey(key);\n  parser.push(value.toString());\n\n  if (options?.TIMESTAMP !== undefined && options?.TIMESTAMP !== null) {\n    parser.push('TIMESTAMP', transformTimestampArgument(options.TIMESTAMP));\n  }\n\n  parseRetentionArgument(parser, options?.RETENTION);\n\n  if (options?.UNCOMPRESSED) {\n    parser.push('UNCOMPRESSED');\n  }\n\n  parseChunkSizeArgument(parser, options?.CHUNK_SIZE);\n\n  parseLabelsArgument(parser, options?.LABELS);\n\n  parseIgnoreArgument(parser, options?.IGNORE);\n}\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(...args: Parameters<typeof parseIncrByArguments>) {\n    const parser = args[0];\n\n    parser.push('TS.INCRBY');\n    parseIncrByArguments(...args);\n  },\n  transformReply: undefined as unknown as () => NumberReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INFO.d.ts

@@ -0,0 +1,73 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, DoubleReply, NumberReply, ReplyUnion, SimpleStringReply, TypeMapping } from "@redis/client/dist/lib/RESP/types";
+import { TimeSeriesDuplicatePolicies } from "./helpers";
+import { TimeSeriesAggregationType } from "./CREATERULE";
+export type InfoRawReplyTypes = SimpleStringReply | NumberReply | TimeSeriesDuplicatePolicies | null | Array<[name: BlobStringReply, value: BlobStringReply]> | BlobStringReply | Array<[key: BlobStringReply, timeBucket: NumberReply, aggregationType: TimeSeriesAggregationType]> | DoubleReply;
+export type InfoRawReply = Array<InfoRawReplyTypes>;
+export type InfoRawReplyOld = [
+    'totalSamples',
+    NumberReply,
+    'memoryUsage',
+    NumberReply,
+    'firstTimestamp',
+    NumberReply,
+    'lastTimestamp',
+    NumberReply,
+    'retentionTime',
+    NumberReply,
+    'chunkCount',
+    NumberReply,
+    'chunkSize',
+    NumberReply,
+    'chunkType',
+    SimpleStringReply,
+    'duplicatePolicy',
+    TimeSeriesDuplicatePolicies | null,
+    'labels',
+    ArrayReply<[name: BlobStringReply, value: BlobStringReply]>,
+    'sourceKey',
+    BlobStringReply | null,
+    'rules',
+    ArrayReply<[key: BlobStringReply, timeBucket: NumberReply, aggregationType: TimeSeriesAggregationType]>,
+    'ignoreMaxTimeDiff',
+    NumberReply,
+    'ignoreMaxValDiff',
+    DoubleReply
+];
+export interface InfoReply {
+    totalSamples: NumberReply;
+    memoryUsage: NumberReply;
+    firstTimestamp: NumberReply;
+    lastTimestamp: NumberReply;
+    retentionTime: NumberReply;
+    chunkCount: NumberReply;
+    chunkSize: NumberReply;
+    chunkType: SimpleStringReply;
+    duplicatePolicy: TimeSeriesDuplicatePolicies | null;
+    labels: Array<{
+        name: BlobStringReply;
+        value: BlobStringReply;
+    }>;
+    sourceKey: BlobStringReply | null;
+    rules: Array<{
+        key: BlobStringReply;
+        timeBucket: NumberReply;
+        aggregationType: TimeSeriesAggregationType;
+    }>;
+    /** Added in 7.4 */
+    ignoreMaxTimeDiff: NumberReply;
+    /** Added in 7.4 */
+    ignoreMaxValDiff: DoubleReply;
+}
+declare function transformInfoReplyResp2(reply: InfoRawReply, _: unknown, typeMapping?: TypeMapping): InfoReply;
+declare function transformInfoReplyResp3(reply: ReplyUnion, preserve?: unknown, typeMapping?: TypeMapping): InfoReply;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: string) => void;
+    readonly transformReply: {
+        readonly 2: typeof transformInfoReplyResp2;
+        readonly 3: typeof transformInfoReplyResp3;
+    };
+};
+export default _default;
+//# sourceMappingURL=INFO.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INFO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"INFO.d.ts","sourceRoot":"","sources":["../../../lib/commands/INFO.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAW,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAC/J,OAAO,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAgC,yBAAyB,EAAE,MAAM,cAAc,CAAC;AASvF,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,GAC/C,WAAW,GACX,2BAA2B,GAAG,IAAI,GAClC,KAAK,CAAC,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,GACtD,eAAe,GACf,KAAK,CAAC,CAAC,GAAG,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,yBAAyB,CAAC,CAAC,GAClG,WAAW,CAAA;AAEb,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAC;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,cAAc;IACd,WAAW;IACX,aAAa;IACb,WAAW;IACX,gBAAgB;IAChB,WAAW;IACX,eAAe;IACf,WAAW;IACX,eAAe;IACf,WAAW;IACX,YAAY;IACZ,WAAW;IACX,WAAW;IACX,WAAW;IACX,WAAW;IACX,iBAAiB;IACjB,iBAAiB;IACjB,2BAA2B,GAAG,IAAI;IAClC,QAAQ;IACR,UAAU,CAAC,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;IAC3D,WAAW;IACX,eAAe,GAAG,IAAI;IACtB,OAAO;IACP,UAAU,CAAC,CAAC,GAAG,EAAE,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,yBAAyB,CAAC,CAAC;IACvG,mBAAmB;IACnB,WAAW;IACX,kBAAkB;IAClB,WAAW;CACZ,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,WAAW,CAAC;IACzB,cAAc,EAAE,WAAW,CAAC;IAC5B,aAAa,EAAE,WAAW,CAAC;IAC3B,aAAa,EAAE,WAAW,CAAC;IAC3B,UAAU,EAAE,WAAW,CAAC;IACxB,SAAS,EAAE,WAAW,CAAC;IACvB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,eAAe,EAAE,2BAA2B,GAAG,IAAI,CAAC;IACpD,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,eAAe,CAAC;QACtB,KAAK,EAAE,eAAe,CAAC;KACxB,CAAC,CAAC;IACH,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC,KAAK,EAAE,KAAK,CAAC;QACX,GAAG,EAAE,eAAe,CAAC;QACrB,UAAU,EAAE,WAAW,CAAC;QACxB,eAAe,EAAE,yBAAyB,CAAA;KAC3C,CAAC,CAAC;IACH,mBAAmB;IACnB,iBAAiB,EAAE,WAAW,CAAC;IAC/B,mBAAmB;IACnB,gBAAgB,EAAE,WAAW,CAAC;CAC/B;AA4HD,iBAAS,uBAAuB,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,CA4CtG;AAED,iBAAS,uBAAuB,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,CAE5G;;;gDAIsB,aAAa,OAAO,MAAM;;;;;;AAFjD,wBAU+B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INFO.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CREATERULE_1 = require("./CREATERULE");
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+const reply_utils_1 = require("@redis/client/dist/lib/commands/reply-utils");
+function normalizeInfoLabels(labels) {
+    if (Array.isArray(labels)) {
+        if (labels.every(item => Array.isArray(item) && item.length >= 2)) {
+            return labels.map(item => [item[0], item[1]]);
+        }
+        const normalized = labels
+            .map(label => {
+            const object = (0, reply_utils_1.mapLikeToObject)(label);
+            return [
+                (0, reply_utils_1.getMapValue)(object, ['name', 'label']),
+                (0, reply_utils_1.getMapValue)(object, ['value'])
+            ];
+        })
+            .filter(([name]) => name !== undefined);
+        if (normalized.length > 0) {
+            return normalized;
+        }
+    }
+    return (0, reply_utils_1.mapLikeEntries)(labels).map(([name, value]) => [name, value]);
+}
+function normalizeInfoRules(rules) {
+    const normalized = [];
+    const aggregationTypes = new Set(Object.values(CREATERULE_1.TIME_SERIES_AGGREGATION_TYPE).map(type => type.toUpperCase()));
+    const parseRuleTuple = (rule) => {
+        const stringCandidates = rule.filter((value) => typeof value === 'string' || value instanceof Buffer);
+        const numberCandidates = rule.filter((value) => typeof value === 'number');
+        const aggregationCandidate = stringCandidates.find(value => {
+            return aggregationTypes.has(value.toString().toUpperCase());
+        });
+        const keyCandidate = stringCandidates.find(value => value !== aggregationCandidate);
+        return [
+            (keyCandidate ?? rule[0]),
+            (numberCandidates[0] ?? Number(rule[1])),
+            (aggregationCandidate ?? rule[2])
+        ];
+    };
+    if (!Array.isArray(rules)) {
+        for (const [key, value] of (0, reply_utils_1.mapLikeEntries)(rules)) {
+            if (Array.isArray(value)) {
+                const timeBucket = value.find(item => typeof item === 'number') ?? Number(value[0]);
+                const aggregationType = value.find(item => {
+                    return (typeof item === 'string' || item instanceof Buffer) &&
+                        aggregationTypes.has(item.toString().toUpperCase());
+                }) ?? value[1];
+                normalized.push([
+                    key,
+                    timeBucket,
+                    aggregationType
+                ]);
+                continue;
+            }
+            const object = (0, reply_utils_1.mapLikeToObject)(value);
+            const timeBucket = (0, reply_utils_1.getMapValue)(object, ['timeBucket', 'time_bucket']);
+            const aggregationType = (0, reply_utils_1.getMapValue)(object, ['aggregationType', 'aggregation_type']);
+            normalized.push([
+                key,
+                timeBucket,
+                aggregationType
+            ]);
+        }
+        return normalized;
+    }
+    if (Array.isArray(rules) && rules.every(rule => Array.isArray(rule) && rule.length >= 3)) {
+        return rules.map(rule => parseRuleTuple(rule));
+    }
+    for (const rule of (0, reply_utils_1.mapLikeValues)(rules)) {
+        if (Array.isArray(rule)) {
+            normalized.push(parseRuleTuple(rule));
+            continue;
+        }
+        const object = (0, reply_utils_1.mapLikeToObject)(rule);
+        const key = (0, reply_utils_1.getMapValue)(object, ['key']);
+        const timeBucket = (0, reply_utils_1.getMapValue)(object, ['timeBucket', 'time_bucket']);
+        const aggregationType = (0, reply_utils_1.getMapValue)(object, ['aggregationType', 'aggregation_type']);
+        normalized.push(parseRuleTuple([key, timeBucket, aggregationType]));
+    }
+    return normalized;
+}
+function normalizeInfoRawReply(reply) {
+    if (Array.isArray(reply)) {
+        return reply;
+    }
+    const normalized = [];
+    for (const [key, value] of (0, reply_utils_1.mapLikeEntries)(reply)) {
+        switch (key) {
+            case 'labels':
+                normalized.push(key, normalizeInfoLabels(value));
+                break;
+            case 'rules':
+                normalized.push(key, normalizeInfoRules(value));
+                break;
+            default:
+                normalized.push(key, value);
+                break;
+        }
+    }
+    return normalized;
+}
+function transformInfoReplyResp2(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[i + 1], undefined, typeMapping);
+                break;
+        }
+    }
+    return ret;
+}
+function transformInfoReplyResp3(reply, preserve, typeMapping) {
+    return transformInfoReplyResp2(normalizeInfoRawReply(reply), preserve, typeMapping);
+}
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, key) {
+        parser.push('TS.INFO');
+        parser.pushKey(key);
+    },
+    transformReply: {
+        2: transformInfoReplyResp2,
+        3: transformInfoReplyResp3
+    },
+};
+//# sourceMappingURL=INFO.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INFO_DEBUG.d.ts

@@ -0,0 +1,36 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { BlobStringReply, NumberReply, SimpleStringReply, TypeMapping, ReplyUnion } from "@redis/client/dist/lib/RESP/types";
+import { InfoRawReplyTypes, InfoReply } from "./INFO";
+type chunkType = Array<[
+    'startTimestamp',
+    NumberReply,
+    'endTimestamp',
+    NumberReply,
+    'samples',
+    NumberReply,
+    'size',
+    NumberReply,
+    'bytesPerSample',
+    SimpleStringReply
+]>;
+export type InfoDebugRawReplyType = InfoRawReplyTypes | chunkType;
+export interface InfoDebugReply extends InfoReply {
+    keySelfName: BlobStringReply;
+    chunks: Array<{
+        startTimestamp: NumberReply;
+        endTimestamp: NumberReply;
+        samples: NumberReply;
+        size: NumberReply;
+        bytesPerSample: SimpleStringReply;
+    }>;
+}
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: string) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: [...InfoRawReplyTypes[], "keySelfName", BlobStringReply<string>, "Chunks", chunkType], _: any, typeMapping?: TypeMapping) => InfoDebugReply;
+        readonly 3: (reply: ReplyUnion, preserve?: unknown, typeMapping?: TypeMapping) => InfoDebugReply;
+    };
+};
+export default _default;
+//# sourceMappingURL=INFO_DEBUG.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INFO_DEBUG.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"INFO_DEBUG.d.ts","sourceRoot":"","sources":["../../../lib/commands/INFO_DEBUG.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAW,WAAW,EAAE,iBAAiB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAEtI,OAAa,EAAgB,iBAAiB,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAE1E,KAAK,SAAS,GAAG,KAAK,CAAC;IACrB,gBAAgB;IAChB,WAAW;IACX,cAAc;IACd,WAAW;IACX,SAAS;IACT,WAAW;IACX,MAAM;IACN,WAAW;IACX,gBAAgB;IAChB,iBAAiB;CAClB,CAAC,CAAC;AAUH,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,GAAG,SAAS,CAAA;AAEjE,MAAM,WAAW,cAAe,SAAQ,SAAS;IAC/C,WAAW,EAAE,eAAe,CAAC;IAC7B,MAAM,EAAE,KAAK,CAAC;QACZ,cAAc,EAAE,WAAW,CAAC;QAC5B,YAAY,EAAE,WAAW,CAAC;QAC1B,OAAO,EAAE,WAAW,CAAC;QACrB,IAAI,EAAE,WAAW,CAAC;QAClB,cAAc,EAAE,iBAAiB,CAAC;KACnC,CAAC,CAAC;CACJ;;;gDAqCsB,aAAa,OAAO,MAAM;;qJAKE,WAAW,KAAG,cAAc;4BA4BhE,UAAU,aAAa,OAAO,gBAAgB,WAAW,KAAG,cAAc;;;AAnCzF,wBA+C6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/INFO_DEBUG.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const reply_utils_1 = require("@redis/client/dist/lib/commands/reply-utils");
+const INFO_1 = __importDefault(require("./INFO"));
+function normalizeChunks(chunks) {
+    return (0, reply_utils_1.mapLikeValues)(chunks).map(chunk => {
+        if (Array.isArray(chunk)) {
+            if (chunk.length >= 10 && chunk[0] === 'startTimestamp') {
+                return {
+                    startTimestamp: chunk[1],
+                    endTimestamp: chunk[3],
+                    samples: chunk[5],
+                    size: chunk[7],
+                    bytesPerSample: chunk[9].toString()
+                };
+            }
+            return {
+                startTimestamp: chunk[0],
+                endTimestamp: chunk[1],
+                samples: chunk[2],
+                size: chunk[3],
+                bytesPerSample: chunk[4].toString()
+            };
+        }
+        const object = (0, reply_utils_1.mapLikeToObject)(chunk);
+        return {
+            startTimestamp: object.startTimestamp ?? object.start_timestamp,
+            endTimestamp: object.endTimestamp ?? object.end_timestamp,
+            samples: object.samples,
+            size: object.size,
+            bytesPerSample: (object.bytesPerSample ?? object.bytes_per_sample).toString()
+        };
+    });
+}
+exports.default = {
+    IS_READ_ONLY: INFO_1.default.IS_READ_ONLY,
+    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: (reply, preserve, typeMapping) => {
+            const ret = INFO_1.default.transformReply[3](reply, preserve, typeMapping);
+            const mappedReply = (0, reply_utils_1.mapLikeToObject)(reply);
+            ret.keySelfName = (mappedReply.keySelfName ?? mappedReply.key_self_name);
+            const chunks = mappedReply.Chunks ?? mappedReply.chunks;
+            ret.chunks = normalizeChunks(chunks);
+            return ret;
+        }
+    },
+};
+//# sourceMappingURL=INFO_DEBUG.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MADD.d.ts

@@ -0,0 +1,15 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { Timestamp } from './helpers';
+import { ArrayReply, NumberReply, SimpleErrorReply } from '@redis/client/dist/lib/RESP/types';
+export interface TsMAddSample {
+    key: string;
+    timestamp: Timestamp;
+    value: number;
+}
+declare const _default: {
+    readonly IS_READ_ONLY: false;
+    readonly parseCommand: (this: void, parser: CommandParser, toAdd: Array<TsMAddSample>) => void;
+    readonly transformReply: () => ArrayReply<NumberReply | SimpleErrorReply>;
+};
+export default _default;
+//# sourceMappingURL=MADD.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MADD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MADD.d.ts","sourceRoot":"","sources":["../../../lib/commands/MADD.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,SAAS,EAA8B,MAAM,WAAW,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAW,MAAM,mCAAmC,CAAC;AAEvG,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;;;gDAIsB,aAAa,SAAS,MAAM,YAAY,CAAC;mCAQhB,WAAW,WAAW,GAAG,gBAAgB,CAAC;;AAV1F,wBAW6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MADD.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MADD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MADD.js","sourceRoot":"","sources":["../../../lib/commands/MADD.ts"],"names":[],"mappings":";;AACA,uCAAkE;AASlE,kBAAe;IACb,YAAY,EAAE,KAAK;IACnB,YAAY,CAAC,MAAqB,EAAE,KAA0B;QAC5D,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEvB,KAAK,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC;YAC9C,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,IAAA,oCAA0B,EAAC,SAAS,CAAC,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IACD,cAAc,EAAE,SAAwE;CAC9D,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Timestamp, transformTimestampArgument } from './helpers';\nimport { ArrayReply, NumberReply, SimpleErrorReply, Command } from '@redis/client/dist/lib/RESP/types';\n\nexport interface TsMAddSample {\n  key: string;\n  timestamp: Timestamp;\n  value: number;\n}\n\nexport default {\n  IS_READ_ONLY: false,\n  parseCommand(parser: CommandParser, toAdd: Array<TsMAddSample>) {\n    parser.push('TS.MADD');\n\n    for (const { key, timestamp, value } of toAdd) {\n      parser.pushKey(key);\n      parser.push(transformTimestampArgument(timestamp), value.toString());\n    }\n  },\n  transformReply: undefined as unknown as () => ArrayReply<NumberReply | SimpleErrorReply>\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET.d.ts

@@ -0,0 +1,49 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { BlobStringReply, ArrayReply, Resp2Reply, MapReply, TuplesReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { SampleRawReply } from './helpers';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+export interface TsMGetOptions {
+    LATEST?: boolean;
+}
+/**
+ * Adds LATEST argument to command if specified
+ * @param parser - The command parser
+ * @param latest - Whether to include the LATEST argument
+ */
+export declare function parseLatestArgument(parser: CommandParser, latest?: boolean): void;
+/**
+ * Adds FILTER argument to command
+ * @param parser - The command parser
+ * @param filter - Filter to match time series keys
+ */
+export declare function parseFilterArgument(parser: CommandParser, filter: RedisVariadicArgument): void;
+export type MGetRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: never,
+    sample: Resp2Reply<SampleRawReply>
+]>>;
+export type MGetRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: never,
+    sample: SampleRawReply
+]>>;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, filter: RedisVariadicArgument, options?: TsMGetOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: MGetRawReply2, _: any, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            sample: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            };
+        }>;
+        readonly 3: (this: void, reply: MGetRawReply3) => MapReply<BlobStringReply<string>, {
+            sample: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            };
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MGET.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MGET.d.ts","sourceRoot":"","sources":["../../../lib/commands/MGET.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACzI,OAAO,EAAoC,cAAc,EAAwB,MAAM,WAAW,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAE7F,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,OAAO,QAI1E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,qBAAqB,QAGvF;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CACpC,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,UAAU,CAAC,cAAc,CAAC;CACnC,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,QAAQ,CAClC,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,cAAc;CACvB,CAAC,CACH,CAAC;;;;gDAKqB,aAAa,UAAU,qBAAqB,YAAY,aAAa;;6EAM/C,WAAW;;;;;;;;;;;;;;AATxD,wBAwB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET.js

@@ -0,0 +1,51 @@
+"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,
+    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

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MGET.js","sourceRoot":"","sources":["../../../lib/commands/MGET.ts"],"names":[],"mappings":";;;AAEA,uCAAmG;AAOnG;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,MAAqB,EAAE,MAAgB;IACzE,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACxB,CAAC;AACH,CAAC;AAJD,kDAIC;AAED;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,MAAqB,EAAE,MAA6B;IACtF,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACtB,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC;AAHD,kDAGC;AAkBD,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,MAA6B,EAAE,OAAuB;QACxF,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvB,mBAAmB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC7C,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,cAAc,EAAE;QACd,CAAC,CAAC,KAAoB,EAAE,CAAC,EAAE,WAAyB;YAClD,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,EAAC,EAAE,MAAM,CAAC,EAAE,EAAE;gBAC5C,OAAO;oBACL,MAAM,EAAE,8BAAoB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;iBACxC,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAAoB;YACpB,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,EAAE;gBAC3C,OAAO;oBACL,MAAM,EAAE,8BAAoB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;iBACxC,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, BlobStringReply, ArrayReply, Resp2Reply, MapReply, TuplesReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';\nimport { resp2MapToValue, resp3MapToValue, SampleRawReply, transformSampleReply } from './helpers';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\n\nexport interface TsMGetOptions {\n  LATEST?: boolean;\n}\n\n/**\n * Adds LATEST argument to command if specified\n * @param parser - The command parser\n * @param latest - Whether to include the LATEST argument\n */\nexport function parseLatestArgument(parser: CommandParser, latest?: boolean) {\n  if (latest) {\n    parser.push('LATEST');\n  }\n}\n\n/**\n * Adds FILTER argument to command\n * @param parser - The command parser\n * @param filter - Filter to match time series keys\n */\nexport function parseFilterArgument(parser: CommandParser, filter: RedisVariadicArgument) {\n  parser.push('FILTER');\n  parser.pushVariadic(filter);\n}\n\nexport type MGetRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: never,\n    sample: Resp2Reply<SampleRawReply>\n  ]>\n>;\n\nexport type MGetRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: never,\n    sample: SampleRawReply\n  ]>\n>;\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, filter: RedisVariadicArgument, options?: TsMGetOptions) {\n    parser.push('TS.MGET');\n    parseLatestArgument(parser, options?.LATEST);\n    parseFilterArgument(parser, filter);\n  },\n  transformReply: {\n    2(reply: MGetRawReply2, _, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([,, sample]) => {\n        return {\n          sample: transformSampleReply[2](sample)\n        };\n      }, typeMapping);\n    },\n    3(reply: MGetRawReply3) {\n      return resp3MapToValue(reply, ([, sample]) => {\n        return {\n          sample: transformSampleReply[3](sample)\n        };\n      });\n    }\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_SELECTED_LABELS.d.ts

@@ -0,0 +1,26 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { BlobStringReply, NullReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { TsMGetOptions } from './MGET';
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, filter: RedisVariadicArgument, selectedLabels: RedisVariadicArgument, options?: TsMGetOptions) => void;
+    readonly transformReply: {
+        2(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply2<NullReply | BlobStringReply<string>>, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined): import("@redis/client/dist/lib/RESP/types").MapReply<BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            sample: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            };
+        }>;
+        3(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply3<NullReply | BlobStringReply<string>>): import("@redis/client/dist/lib/RESP/types").MapReply<BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            sample: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            };
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MGET_SELECTED_LABELS.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_SELECTED_LABELS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MGET_SELECTED_LABELS.d.ts","sourceRoot":"","sources":["../../../lib/commands/MGET_SELECTED_LABELS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,eAAe,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACxF,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,aAAa,EAA4C,MAAM,QAAQ,CAAC;;;gDAM1D,aAAa,UAAU,qBAAqB,kBAAkB,qBAAqB,YAAY,aAAa;;;;;;;;;;;;;;;;;;AAFnI,wBAS6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_SELECTED_LABELS.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MGET_1 = require("./MGET");
+const helpers_1 = require("./helpers");
+const MGET_WITHLABELS_1 = require("./MGET_WITHLABELS");
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, filter, selectedLabels, options) {
+        parser.push('TS.MGET');
+        (0, MGET_1.parseLatestArgument)(parser, options?.LATEST);
+        (0, helpers_1.parseSelectedLabelsArguments)(parser, selectedLabels);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    },
+    transformReply: (0, MGET_WITHLABELS_1.createTransformMGetLabelsReply)(),
+};
+//# sourceMappingURL=MGET_SELECTED_LABELS.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_SELECTED_LABELS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MGET_SELECTED_LABELS.js","sourceRoot":"","sources":["../../../lib/commands/MGET_SELECTED_LABELS.ts"],"names":[],"mappings":";;AAGA,iCAAiF;AACjF,uCAAyD;AACzD,uDAAmE;AAEnE,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,MAA6B,EAAE,cAAqC,EAAE,OAAuB;QAC/H,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvB,IAAA,0BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC7C,IAAA,sCAA4B,EAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QACrD,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,cAAc,EAAE,IAAA,gDAA8B,GAA+B;CACnD,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, BlobStringReply, NullReply } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { TsMGetOptions, parseLatestArgument, parseFilterArgument } from './MGET';\nimport { parseSelectedLabelsArguments } from './helpers';\nimport { createTransformMGetLabelsReply } from './MGET_WITHLABELS';\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, filter: RedisVariadicArgument, selectedLabels: RedisVariadicArgument, options?: TsMGetOptions) {\n    parser.push('TS.MGET');\n    parseLatestArgument(parser, options?.LATEST);\n    parseSelectedLabelsArguments(parser, selectedLabels);\n    parseFilterArgument(parser, filter);\n  },\n  transformReply: createTransformMGetLabelsReply<BlobStringReply | NullReply>(),\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_WITHLABELS.d.ts

@@ -0,0 +1,58 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { BlobStringReply, ArrayReply, Resp2Reply, MapReply, TuplesReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { TsMGetOptions } from './MGET';
+import { RawLabelValue, SampleRawReply } from './helpers';
+export interface TsMGetWithLabelsOptions extends TsMGetOptions {
+    SELECTED_LABELS?: RedisVariadicArgument;
+}
+export type MGetLabelsRawReply2<T extends RawLabelValue> = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: ArrayReply<TuplesReply<[
+        label: BlobStringReply,
+        value: T
+    ]>>,
+    sample: Resp2Reply<SampleRawReply>
+]>>;
+export type MGetLabelsRawReply3<T extends RawLabelValue> = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, T>,
+    sample: SampleRawReply
+]>>;
+export declare function createTransformMGetLabelsReply<T extends RawLabelValue>(): {
+    2(this: void, reply: MGetLabelsRawReply2<T>, _: any, typeMapping?: TypeMapping): MapReply<BlobStringReply<string>, {
+        labels: MapReply<BlobStringReply<string>, T>;
+        sample: {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: number;
+        };
+    }>;
+    3(this: void, reply: MGetLabelsRawReply3<T>): MapReply<BlobStringReply<string>, {
+        labels: MapReply<BlobStringReply<string>, T>;
+        sample: {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+        };
+    }>;
+};
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, filter: RedisVariadicArgument, options?: TsMGetWithLabelsOptions) => void;
+    readonly transformReply: {
+        2(this: void, reply: MGetLabelsRawReply2<BlobStringReply<string>>, _: any, typeMapping?: TypeMapping | undefined): MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
+            sample: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            };
+        }>;
+        3(this: void, reply: MGetLabelsRawReply3<BlobStringReply<string>>): MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
+            sample: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            };
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MGET_WITHLABELS.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_WITHLABELS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MGET_WITHLABELS.d.ts","sourceRoot":"","sources":["../../../lib/commands/MGET_WITHLABELS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AACzI,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,aAAa,EAA4C,MAAM,QAAQ,CAAC;AACjF,OAAO,EAAE,aAAa,EAAoC,cAAc,EAA8C,MAAM,WAAW,CAAC;AAExI,MAAM,WAAW,uBAAwB,SAAQ,aAAa;IAC5D,eAAe,CAAC,EAAE,qBAAqB,CAAC;CACzC;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,aAAa,IAAI,UAAU,CACnE,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,UAAU,CAChB,WAAW,CAAC;QACV,KAAK,EAAE,eAAe;QACtB,KAAK,EAAE,CAAC;KACT,CAAC,CACH;IACD,MAAM,EAAE,UAAU,CAAC,cAAc,CAAC;CACnC,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,aAAa,IAAI,QAAQ,CACjE,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC,CAAC;IACpC,MAAM,EAAE,cAAc;CACvB,CAAC,CACH,CAAC;AAEF,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,aAAa;yBAEzD,oBAAoB,CAAC,CAAC,wBAAmB,WAAW;;;;;;;;;;;;;;EAiBhE;;;gDAIsB,aAAa,UAAU,qBAAqB,YAAY,uBAAuB;;;;;;;;;;;;;;;;;;AAFtG,wBAS6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_WITHLABELS.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMGetLabelsReply = void 0;
+const MGET_1 = require("./MGET");
+const helpers_1 = require("./helpers");
+function createTransformMGetLabelsReply() {
+    return {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([, labels, sample]) => {
+                return {
+                    labels: (0, helpers_1.transformRESP2Labels)(labels),
+                    sample: helpers_1.transformSampleReply[2](sample)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, sample]) => {
+                return {
+                    labels,
+                    sample: helpers_1.transformSampleReply[3](sample)
+                };
+            });
+        }
+    };
+}
+exports.createTransformMGetLabelsReply = createTransformMGetLabelsReply;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(parser, filter, options) {
+        parser.push('TS.MGET');
+        (0, MGET_1.parseLatestArgument)(parser, options?.LATEST);
+        parser.push('WITHLABELS');
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    },
+    transformReply: createTransformMGetLabelsReply(),
+};
+//# sourceMappingURL=MGET_WITHLABELS.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MGET_WITHLABELS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MGET_WITHLABELS.js","sourceRoot":"","sources":["../../../lib/commands/MGET_WITHLABELS.ts"],"names":[],"mappings":";;;AAGA,iCAAiF;AACjF,uCAAwI;AA2BxI,SAAgB,8BAA8B;IAC5C,OAAO;QACL,CAAC,CAAC,KAA6B,EAAE,CAAC,EAAE,WAAyB;YAC3D,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE;gBACnD,OAAO;oBACL,MAAM,EAAE,IAAA,8BAAoB,EAAC,MAAM,CAAC;oBACpC,MAAM,EAAE,8BAAoB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;iBACxC,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAA6B;YAC7B,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE;gBACjD,OAAO;oBACL,MAAM;oBACN,MAAM,EAAE,8BAAoB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;iBACxC,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACkC,CAAC;AACxC,CAAC;AAnBD,wEAmBC;AAED,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,MAA6B,EAAE,OAAiC;QAClG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvB,IAAA,0BAAmB,EAAC,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC1B,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,cAAc,EAAE,8BAA8B,EAAmB;CACvC,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, BlobStringReply, ArrayReply, Resp2Reply, MapReply, TuplesReply, TypeMapping } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { TsMGetOptions, parseLatestArgument, parseFilterArgument } from './MGET';\nimport { RawLabelValue, resp2MapToValue, resp3MapToValue, SampleRawReply, transformRESP2Labels, transformSampleReply } from './helpers';\n\nexport interface TsMGetWithLabelsOptions extends TsMGetOptions {\n  SELECTED_LABELS?: RedisVariadicArgument;\n}\n\nexport type MGetLabelsRawReply2<T extends RawLabelValue> = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: ArrayReply<\n      TuplesReply<[\n        label: BlobStringReply,\n        value: T\n      ]>\n    >,\n    sample: Resp2Reply<SampleRawReply>\n  ]>\n>;\n\nexport type MGetLabelsRawReply3<T extends RawLabelValue> = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, T>,\n    sample: SampleRawReply\n  ]>\n>;\n\nexport function createTransformMGetLabelsReply<T extends RawLabelValue>() {\n  return {\n    2(reply: MGetLabelsRawReply2<T>, _, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([, labels, sample]) => {\n        return {\n          labels: transformRESP2Labels(labels),\n          sample: transformSampleReply[2](sample)\n        };\n      }, typeMapping);\n    },\n    3(reply: MGetLabelsRawReply3<T>) {\n      return resp3MapToValue(reply, ([labels, sample]) => {\n        return {\n          labels,\n          sample: transformSampleReply[3](sample)\n        };\n      });\n    }\n  } satisfies Command['transformReply'];\n}\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, filter: RedisVariadicArgument, options?: TsMGetWithLabelsOptions) {\n    parser.push('TS.MGET');\n    parseLatestArgument(parser, options?.LATEST);\n    parser.push('WITHLABELS');\n    parseFilterArgument(parser, filter);\n  },\n  transformReply: createTransformMGetLabelsReply<BlobStringReply>(),\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE.d.ts

@@ -0,0 +1,37 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { SampleRawReply, Timestamp } from './helpers';
+import { TsRangeOptions } from './RANGE';
+export type TsMRangeRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: never,
+    samples: ArrayReply<Resp2Reply<SampleRawReply>>
+]>>;
+export type TsMRangeRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: never,
+    metadata: never,
+    samples: ArrayReply<SampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsRangeOptions) => void;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: number;
+        }[]>;
+        readonly 3: (this: void, reply: TsMRangeRawReply3) => MapReply<BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+        }[]>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACxJ,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAoC,cAAc,EAAE,SAAS,EAAyB,MAAM,WAAW,CAAC;AAC/G,OAAO,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAG9D,MAAM,MAAM,iBAAiB,GAAG,UAAU,CACxC,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;CAChD,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CACtC,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,KAAK;IACb,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC;CACpC,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,aAAa,YAEzD,aAAa,iBACN,SAAS,eACX,SAAS,UACd,qBAAqB,YACnB,cAAc,UAY3B;;;;;;+DAOmC,OAAO,gBAAgB,WAAW;;;;;;;;;;AALtE,wBAgB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMRangeArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_1 = require("./RANGE");
+const MGET_1 = require("./MGET");
+/**
+ * Creates a function that parses arguments for multi-range commands
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, filter, options) => {
+        parser.push(command);
+        (0, RANGE_1.parseRangeArguments)(parser, fromTimestamp, toTimestamp, options);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    };
+}
+exports.createTransformMRangeArguments = createTransformMRangeArguments;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, _labels, samples]) => {
+                return helpers_1.transformSamplesReply[2](samples);
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([_labels, _metadata, samples]) => {
+                return helpers_1.transformSamplesReply[3](samples);
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE.ts"],"names":[],"mappings":";;;AAGA,uCAA+G;AAC/G,mCAA8D;AAC9D,iCAA6C;AAmB7C;;;GAGG;AACH,SAAgB,8BAA8B,CAAC,OAAsB;IACnE,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,MAA6B,EAC7B,OAAwB,EACxB,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,2BAAmB,EACjB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AAlBD,wEAkBC;AAED,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,8BAA8B,CAAC,WAAW,CAAC;IACzD,cAAc,EAAE;QACd,CAAC,CAAC,KAAwB,EAAE,CAAW,EAAE,WAAyB;YAChE,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;gBACzD,OAAO,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC3C,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAAwB;YACxB,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBAC9D,OAAO,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { resp2MapToValue, resp3MapToValue, SampleRawReply, Timestamp, transformSamplesReply } from './helpers';\nimport { TsRangeOptions, parseRangeArguments } from './RANGE';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: never, // empty array without WITHLABELS or SELECTED_LABELS\n    samples: ArrayReply<Resp2Reply<SampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: never, // empty hash without WITHLABELS or SELECTED_LABELS\n    metadata: never, // ?!\n    samples: ArrayReply<SampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createTransformMRangeArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    filter: RedisVariadicArgument,\n    options?: TsRangeOptions\n  ) => {\n    parser.push(command);\n    parseRangeArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n  \n    parseFilterArgument(parser, filter);\n  };\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand: createTransformMRangeArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, _labels, samples]) => {\n        return transformSamplesReply[2](samples);\n      }, typeMapping);\n    },\n    3(reply: TsMRangeRawReply3) {\n      return resp3MapToValue(reply, ([_labels, _metadata, samples]) => {\n        return transformSamplesReply[3](samples);\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_GROUPBY.d.ts

@@ -0,0 +1,83 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument, TuplesToMapReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { SampleRawReply, Timestamp } from './helpers';
+import { TsRangeOptions } from './RANGE';
+export declare const TIME_SERIES_REDUCERS: {
+    readonly AVG: "AVG";
+    readonly SUM: "SUM";
+    readonly MIN: "MIN";
+    readonly MAX: "MAX";
+    readonly RANGE: "RANGE";
+    readonly COUNT: "COUNT";
+    /**
+    * Available since 8.6
+    */
+    readonly COUNTNAN: "COUNTNAN";
+    /**
+    * Available since 8.6
+    */
+    readonly COUNTALL: "COUNTALL";
+    readonly STD_P: "STD.P";
+    readonly STD_S: "STD.S";
+    readonly VAR_P: "VAR.P";
+    readonly VAR_S: "VAR.S";
+};
+export type TimeSeriesReducer = typeof TIME_SERIES_REDUCERS[keyof typeof TIME_SERIES_REDUCERS];
+export interface TsMRangeGroupBy {
+    label: RedisArgument;
+    REDUCE: TimeSeriesReducer;
+}
+/**
+ * Adds GROUPBY arguments to command
+ * @param parser - The command parser
+ * @param groupBy - Group by parameters
+ */
+export declare function parseGroupByArguments(parser: CommandParser, groupBy: TsMRangeGroupBy): void;
+export type TsMRangeGroupByRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: never,
+    samples: ArrayReply<Resp2Reply<SampleRawReply>>
+]>>;
+export type TsMRangeGroupByRawMetadataReply3 = TuplesToMapReply<[
+    [
+        BlobStringReply<'sources'>,
+        ArrayReply<BlobStringReply>
+    ]
+]>;
+export type TsMRangeGroupByRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: never,
+    metadata1: never,
+    metadata2: TsMRangeGroupByRawMetadataReply3,
+    samples: ArrayReply<SampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with grouping
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeGroupByArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, groupBy: TsMRangeGroupBy, options?: TsRangeOptions) => void;
+/**
+ * Extracts source keys from RESP3 metadata reply
+ * @param raw - Raw metadata from RESP3 reply
+ */
+export declare function extractResp3MRangeSources(raw: TsMRangeGroupByRawMetadataReply3): ArrayReply<BlobStringReply<string>>;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, groupBy: TsMRangeGroupBy, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeGroupByRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeGroupByRawReply3) => MapReply<BlobStringReply<string>, {
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_GROUPBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_GROUPBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_GROUPBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_GROUPBY.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAe,MAAM,mCAAmC,CAAC;AACvL,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAoC,cAAc,EAAE,SAAS,EAAyB,MAAM,WAAW,CAAC;AAC/G,OAAO,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAG9D,eAAO,MAAM,oBAAoB;;;;;;;IAO/B;;MAEE;;IAEF;;MAEE;;;;;;CAMM,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,OAAO,oBAAoB,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAE/F,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,eAAe,QAEpF;AAED,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAC/C,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;CAChD,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,gBAAgB,CAAC;IAC9D;QAAC,eAAe,CAAC,SAAS,CAAC;QAAE,UAAU,CAAC,eAAe,CAAC;KAAC;CAC1D,CAAC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,QAAQ,CAC7C,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,KAAK;IACb,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,gCAAgC;IAC3C,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC;CACpC,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qCAAqC,CAAC,OAAO,EAAE,aAAa,YAEhE,aAAa,iBACN,SAAS,eACX,SAAS,UACd,qBAAqB,WACpB,eAAe,YACd,cAAc,UAS3B;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,gCAAgC,uCAS9E;;;;;sEAM0C,OAAO,gBAAgB,WAAW;;;;;;;;;;;;;;AAJ7E,wBAmB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_GROUPBY.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResp3MRangeSources = exports.createTransformMRangeGroupByArguments = exports.parseGroupByArguments = exports.TIME_SERIES_REDUCERS = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_1 = require("./RANGE");
+const MGET_1 = require("./MGET");
+exports.TIME_SERIES_REDUCERS = {
+    AVG: 'AVG',
+    SUM: 'SUM',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    RANGE: 'RANGE',
+    COUNT: 'COUNT',
+    /**
+    * Available since 8.6
+    */
+    COUNTNAN: 'COUNTNAN',
+    /**
+    * Available since 8.6
+    */
+    COUNTALL: 'COUNTALL',
+    STD_P: 'STD.P',
+    STD_S: 'STD.S',
+    VAR_P: 'VAR.P',
+    VAR_S: 'VAR.S'
+};
+/**
+ * Adds GROUPBY arguments to command
+ * @param parser - The command parser
+ * @param groupBy - Group by parameters
+ */
+function parseGroupByArguments(parser, groupBy) {
+    parser.push('GROUPBY', groupBy.label, 'REDUCE', groupBy.REDUCE);
+}
+exports.parseGroupByArguments = parseGroupByArguments;
+/**
+ * Creates a function that parses arguments for multi-range commands with grouping
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeGroupByArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, filter, groupBy, options) => {
+        parser.push(command);
+        (0, RANGE_1.parseRangeArguments)(parser, fromTimestamp, toTimestamp, options);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+        parseGroupByArguments(parser, groupBy);
+    };
+}
+exports.createTransformMRangeGroupByArguments = createTransformMRangeGroupByArguments;
+/**
+ * Extracts source keys from RESP3 metadata reply
+ * @param raw - Raw metadata from RESP3 reply
+ */
+function extractResp3MRangeSources(raw) {
+    const unwrappedMetadata2 = raw;
+    if (unwrappedMetadata2 instanceof Map) {
+        return unwrappedMetadata2.get('sources');
+    }
+    else if (unwrappedMetadata2 instanceof Array) {
+        return unwrappedMetadata2[1];
+    }
+    else {
+        return unwrappedMetadata2.sources;
+    }
+}
+exports.extractResp3MRangeSources = extractResp3MRangeSources;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeGroupByArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, _labels, samples]) => {
+                return {
+                    samples: helpers_1.transformSamplesReply[2](samples)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([_labels, _metadata1, _metadata2, samples]) => {
+                return {
+                    samples: helpers_1.transformSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_GROUPBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_MULTIAGGR.d.ts

@@ -0,0 +1,37 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { MultiAggregationSampleRawReply, Timestamp } from './helpers';
+import { TsRangeMultiAggrOptions } from './RANGE_MULTIAGGR';
+export type TsMRangeMultiRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: never,
+    samples: ArrayReply<Resp2Reply<MultiAggregationSampleRawReply>>
+]>>;
+export type TsMRangeMultiRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: never,
+    metadata: never,
+    samples: ArrayReply<MultiAggregationSampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with multiple aggregators
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeMultiArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options: TsRangeMultiAggrOptions) => void;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options: TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeMultiRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: number[];
+        }[]>;
+        readonly 3: (this: void, reply: TsMRangeMultiRawReply3) => MapReply<BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+        }[]>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_MULTIAGGR.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACxJ,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAGL,8BAA8B,EAC9B,SAAS,EAEV,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,uBAAuB,EAA4B,MAAM,mBAAmB,CAAC;AAGtF,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAC7C,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,8BAA8B,CAAC,CAAC;CAChE,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAC3C,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,KAAK;IACb,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,UAAU,CAAC,8BAA8B,CAAC;CACpD,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mCAAmC,CAAC,OAAO,EAAE,aAAa,YAE9D,aAAa,iBACN,SAAS,eACX,SAAS,UACd,qBAAqB,WACpB,uBAAuB,UAYnC;;;;;;oEAOwC,OAAO,gBAAgB,WAAW;;;;;;;;;;AAL3E,wBAgB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_MULTIAGGR.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMRangeMultiArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_MULTIAGGR_1 = require("./RANGE_MULTIAGGR");
+const MGET_1 = require("./MGET");
+/**
+ * Creates a function that parses arguments for multi-range commands with multiple aggregators
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeMultiArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, filter, options) => {
+        parser.push(command);
+        (0, RANGE_MULTIAGGR_1.parseRangeMultiArguments)(parser, fromTimestamp, toTimestamp, options);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    };
+}
+exports.createTransformMRangeMultiArguments = createTransformMRangeMultiArguments;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeMultiArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, _labels, samples]) => {
+                return helpers_1.transformMultiAggregationSamplesReply[2](samples);
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([_labels, _metadata, samples]) => {
+                return helpers_1.transformMultiAggregationSamplesReply[3](samples);
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_MULTIAGGR.ts"],"names":[],"mappings":";;;AAGA,uCAMmB;AACnB,uDAAsF;AACtF,iCAA6C;AAmB7C;;;GAGG;AACH,SAAgB,mCAAmC,CAAC,OAAsB;IACxE,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,MAA6B,EAC7B,OAAgC,EAChC,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,0CAAwB,EACtB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AAlBD,kFAkBC;AAED,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,mCAAmC,CAAC,WAAW,CAAC;IAC9D,cAAc,EAAE;QACd,CAAC,CAAC,KAA6B,EAAE,CAAW,EAAE,WAAyB;YACrE,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;gBACzD,OAAO,+CAAqC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC3D,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAA6B;YAC7B,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBAC9D,OAAO,+CAAqC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC3D,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport {\n  resp2MapToValue,\n  resp3MapToValue,\n  MultiAggregationSampleRawReply,\n  Timestamp,\n  transformMultiAggregationSamplesReply\n} from './helpers';\nimport { TsRangeMultiAggrOptions, parseRangeMultiArguments } from './RANGE_MULTIAGGR';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeMultiRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: never, // empty array without WITHLABELS or SELECTED_LABELS\n    samples: ArrayReply<Resp2Reply<MultiAggregationSampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeMultiRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: never, // empty hash without WITHLABELS or SELECTED_LABELS\n    metadata: never, // ?!\n    samples: ArrayReply<MultiAggregationSampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands with multiple aggregators\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createTransformMRangeMultiArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    filter: RedisVariadicArgument,\n    options: TsRangeMultiAggrOptions\n  ) => {\n    parser.push(command);\n    parseRangeMultiArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n\n    parseFilterArgument(parser, filter);\n  };\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand: createTransformMRangeMultiArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeMultiRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, _labels, samples]) => {\n        return transformMultiAggregationSamplesReply[2](samples);\n      }, typeMapping);\n    },\n    3(reply: TsMRangeMultiRawReply3) {\n      return resp3MapToValue(reply, ([_labels, _metadata, samples]) => {\n        return transformMultiAggregationSamplesReply[3](samples);\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS.d.ts

@@ -0,0 +1,45 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, NullReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { SampleRawReply, Timestamp } from './helpers';
+import { TsRangeOptions } from './RANGE';
+export type TsMRangeSelectedLabelsRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: ArrayReply<TuplesReply<[
+        label: BlobStringReply,
+        value: BlobStringReply | NullReply
+    ]>>,
+    samples: ArrayReply<Resp2Reply<SampleRawReply>>
+]>>;
+export type TsMRangeSelectedLabelsRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, BlobStringReply | NullReply>,
+    metadata: unknown,
+    samples: ArrayReply<SampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with selected labels
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeSelectedLabelsArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, selectedLabels: RedisVariadicArgument, filter: RedisVariadicArgument, options?: TsRangeOptions) => void;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, selectedLabels: RedisVariadicArgument, filter: RedisVariadicArgument, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeSelectedLabelsRawReply3) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_SELECTED_LABELS.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_SELECTED_LABELS.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_SELECTED_LABELS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACnK,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAkE,cAAc,EAAE,SAAS,EAA+C,MAAM,WAAW,CAAC;AACnK,OAAO,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAG9D,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;QAC7B,KAAK,EAAE,eAAe;QACtB,KAAK,EAAE,eAAe,GAAG,SAAS;KACnC,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;CAChD,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CACpD,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC;IAG9D,QAAQ,EAAE,OAAO;IACjB,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC;CACpC,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,4CAA4C,CAAC,OAAO,EAAE,aAAa,YAEvE,aAAa,iBACN,SAAS,eACX,SAAS,kBACN,qBAAqB,UAC7B,qBAAqB,YACnB,cAAc,UAc3B;;;;;6EAMiD,OAAO,gBAAgB,WAAW;;;;;;;;;;;;;;;;AAJpF,wBAqB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMRangeSelectedLabelsArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_1 = require("./RANGE");
+const MGET_1 = require("./MGET");
+/**
+ * Creates a function that parses arguments for multi-range commands with selected labels
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeSelectedLabelsArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, selectedLabels, filter, options) => {
+        parser.push(command);
+        (0, RANGE_1.parseRangeArguments)(parser, fromTimestamp, toTimestamp, options);
+        (0, helpers_1.parseSelectedLabelsArguments)(parser, selectedLabels);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    };
+}
+exports.createTransformMRangeSelectedLabelsArguments = createTransformMRangeSelectedLabelsArguments;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeSelectedLabelsArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, labels, samples]) => {
+                return {
+                    labels: (0, helpers_1.transformRESP2Labels)(labels, typeMapping),
+                    samples: helpers_1.transformSamplesReply[2](samples)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, _metadata, samples]) => {
+                return {
+                    labels,
+                    samples: helpers_1.transformSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_SELECTED_LABELS.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_SELECTED_LABELS.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_SELECTED_LABELS.ts"],"names":[],"mappings":";;;AAGA,uCAAmK;AACnK,mCAA8D;AAC9D,iCAA6C;AAwB7C;;;GAGG;AACH,SAAgB,4CAA4C,CAAC,OAAsB;IACjF,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,cAAqC,EACrC,MAA6B,EAC7B,OAAwB,EACxB,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,2BAAmB,EACjB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,IAAA,sCAA4B,EAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAErD,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AArBD,oGAqBC;AAED,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,4CAA4C,CAAC,WAAW,CAAC;IACvE,cAAc,EAAE;QACd,CAAC,CAAC,KAAsC,EAAE,CAAW,EAAE,WAAyB;YAC9E,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;gBACxD,OAAO;oBACL,MAAM,EAAE,IAAA,8BAAoB,EAAC,MAAM,EAAE,WAAW,CAAC;oBACjD,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAAsC;YACtC,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBAC7D,OAAO;oBACL,MAAM;oBACN,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, NullReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { parseSelectedLabelsArguments, resp2MapToValue, resp3MapToValue, SampleRawReply, Timestamp, transformRESP2Labels, transformSamplesReply } from './helpers';\nimport { TsRangeOptions, parseRangeArguments } from './RANGE';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeSelectedLabelsRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: ArrayReply<TuplesReply<[\n      label: BlobStringReply,\n      value: BlobStringReply | NullReply\n    ]>>,\n    samples: ArrayReply<Resp2Reply<SampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeSelectedLabelsRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, BlobStringReply | NullReply>,\n    // Redis 7.4 leaves this slot empty; Redis 8 may populate it with\n    // aggregation/reducer metadata. We don't consume it, so accept anything.\n    metadata: unknown,\n    samples: ArrayReply<SampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands with selected labels\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createTransformMRangeSelectedLabelsArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    selectedLabels: RedisVariadicArgument,\n    filter: RedisVariadicArgument,\n    options?: TsRangeOptions\n  ) => {\n    parser.push(command);\n    parseRangeArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n  \n    parseSelectedLabelsArguments(parser, selectedLabels);\n  \n    parseFilterArgument(parser, filter);\n  };\n}\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand: createTransformMRangeSelectedLabelsArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, labels, samples]) => {\n        return {\n          labels: transformRESP2Labels(labels, typeMapping),\n          samples: transformSamplesReply[2](samples)\n        };\n      }, typeMapping);\n    },\n    3(reply: TsMRangeSelectedLabelsRawReply3) {\n      return resp3MapToValue(reply, ([labels, _metadata, samples]) => {\n        return {\n          labels,\n          samples: transformSamplesReply[3](samples)\n        };\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_GROUPBY.d.ts

@@ -0,0 +1,39 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, MapReply, TuplesReply, RedisArgument, NullReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { SampleRawReply, Timestamp } from './helpers';
+import { TsRangeOptions } from './RANGE';
+import { TsMRangeGroupBy, TsMRangeGroupByRawMetadataReply3 } from './MRANGE_GROUPBY';
+export type TsMRangeWithLabelsGroupByRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, BlobStringReply | NullReply>,
+    metadata: never,
+    metadata2: TsMRangeGroupByRawMetadataReply3,
+    samples: ArrayReply<SampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with selected labels and grouping
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createMRangeSelectedLabelsGroupByTransformArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, selectedLabels: RedisVariadicArgument, filter: RedisVariadicArgument, groupBy: TsMRangeGroupBy, options?: TsRangeOptions) => void;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, selectedLabels: RedisVariadicArgument, filter: RedisVariadicArgument, groupBy: TsMRangeGroupBy, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeWithLabelsGroupByRawReply3) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_SELECTED_LABELS_GROUPBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_GROUPBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_SELECTED_LABELS_GROUPBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_SELECTED_LABELS_GROUPBY.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC1I,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAiD,cAAc,EAAE,SAAS,EAAyB,MAAM,WAAW,CAAC;AAC5H,OAAO,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAC9D,OAAO,EAAyB,eAAe,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAC;AAI5G,MAAM,MAAM,kCAAkC,GAAG,QAAQ,CACvD,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9D,QAAQ,EAAE,KAAK;IACf,SAAS,EAAE,gCAAgC;IAC3C,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC;CACpC,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mDAAmD,CACjE,OAAO,EAAE,aAAa,YAGZ,aAAa,iBACN,SAAS,eACX,SAAS,kBACN,qBAAqB,UAC7B,qBAAqB,WACpB,eAAe,YACd,cAAc,UAgB3B;;;;;;;;;;;;;;;;;;;;;AAED,wBAc6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_GROUPBY.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMRangeSelectedLabelsGroupByTransformArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_1 = require("./RANGE");
+const MRANGE_GROUPBY_1 = require("./MRANGE_GROUPBY");
+const MGET_1 = require("./MGET");
+const MRANGE_SELECTED_LABELS_1 = __importDefault(require("./MRANGE_SELECTED_LABELS"));
+/**
+ * Creates a function that parses arguments for multi-range commands with selected labels and grouping
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createMRangeSelectedLabelsGroupByTransformArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, selectedLabels, filter, groupBy, options) => {
+        parser.push(command);
+        (0, RANGE_1.parseRangeArguments)(parser, fromTimestamp, toTimestamp, options);
+        (0, helpers_1.parseSelectedLabelsArguments)(parser, selectedLabels);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+        (0, MRANGE_GROUPBY_1.parseGroupByArguments)(parser, groupBy);
+    };
+}
+exports.createMRangeSelectedLabelsGroupByTransformArguments = createMRangeSelectedLabelsGroupByTransformArguments;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand: createMRangeSelectedLabelsGroupByTransformArguments('TS.MRANGE'),
+    transformReply: {
+        2: MRANGE_SELECTED_LABELS_1.default.transformReply[2],
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, _metadata, _metadata2, samples]) => {
+                return {
+                    labels,
+                    samples: helpers_1.transformSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_SELECTED_LABELS_GROUPBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_GROUPBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_SELECTED_LABELS_GROUPBY.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_SELECTED_LABELS_GROUPBY.ts"],"names":[],"mappings":";;;;;;AAGA,uCAA4H;AAC5H,mCAA8D;AAC9D,qDAA4G;AAC5G,iCAA6C;AAC7C,sFAA8D;AAY9D;;;GAGG;AACH,SAAgB,mDAAmD,CACjE,OAAsB;IAEtB,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,cAAqC,EACrC,MAA6B,EAC7B,OAAwB,EACxB,OAAwB,EACxB,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,2BAAmB,EACjB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,IAAA,sCAA4B,EAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAErD,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAEpC,IAAA,sCAAqB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC,CAAC;AACJ,CAAC;AA1BD,kHA0BC;AAED,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,mDAAmD,CAAC,WAAW,CAAC;IAC9E,cAAc,EAAE;QACd,CAAC,EAAE,gCAAsB,CAAC,cAAc,CAAC,CAAC,CAAC;QAC3C,CAAC,CAAC,KAAyC;YACzC,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,EAAE;gBACzE,OAAO;oBACL,MAAM;oBACN,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ArrayReply, BlobStringReply, MapReply, TuplesReply, RedisArgument, NullReply } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { parseSelectedLabelsArguments, resp3MapToValue, SampleRawReply, Timestamp, transformSamplesReply } from './helpers';\nimport { TsRangeOptions, parseRangeArguments } from './RANGE';\nimport { parseGroupByArguments, TsMRangeGroupBy, TsMRangeGroupByRawMetadataReply3 } from './MRANGE_GROUPBY';\nimport { parseFilterArgument } from './MGET';\nimport MRANGE_SELECTED_LABELS from './MRANGE_SELECTED_LABELS';\n\nexport type TsMRangeWithLabelsGroupByRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, BlobStringReply | NullReply>,\n    metadata: never, // ?!\n    metadata2: TsMRangeGroupByRawMetadataReply3,\n    samples: ArrayReply<SampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands with selected labels and grouping\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createMRangeSelectedLabelsGroupByTransformArguments(\n  command: RedisArgument\n) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    selectedLabels: RedisVariadicArgument,\n    filter: RedisVariadicArgument,\n    groupBy: TsMRangeGroupBy,\n    options?: TsRangeOptions\n  ) => {\n    parser.push(command);\n    parseRangeArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n  \n    parseSelectedLabelsArguments(parser, selectedLabels);\n  \n    parseFilterArgument(parser, filter);\n  \n    parseGroupByArguments(parser, groupBy);\n  };\n}\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand: createMRangeSelectedLabelsGroupByTransformArguments('TS.MRANGE'),\n  transformReply: {\n    2: MRANGE_SELECTED_LABELS.transformReply[2],\n    3(reply: TsMRangeWithLabelsGroupByRawReply3) {\n      return resp3MapToValue(reply, ([labels, _metadata, _metadata2, samples]) => {\n        return {\n          labels,\n          samples: transformSamplesReply[3](samples)\n        };\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_MULTIAGGR.d.ts

@@ -0,0 +1,46 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, NullReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { MultiAggregationSampleRawReply, Timestamp } from './helpers';
+import { TsRangeMultiAggrOptions } from './RANGE_MULTIAGGR';
+export type TsMRangeSelectedLabelsMultiRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: ArrayReply<TuplesReply<[
+        label: BlobStringReply,
+        value: BlobStringReply | NullReply
+    ]>>,
+    samples: ArrayReply<Resp2Reply<MultiAggregationSampleRawReply>>
+]>>;
+export type TsMRangeSelectedLabelsMultiRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, BlobStringReply | NullReply>,
+    metadata: never,
+    samples: ArrayReply<MultiAggregationSampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with selected labels and multiple aggregators
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeSelectedLabelsMultiArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, selectedLabels: RedisVariadicArgument, filter: RedisVariadicArgument, options: TsRangeMultiAggrOptions) => void;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, selectedLabels: RedisVariadicArgument, filter: RedisVariadicArgument, options: TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeSelectedLabelsMultiRawReply3) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_SELECTED_LABELS_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_SELECTED_LABELS_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_SELECTED_LABELS_MULTIAGGR.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACnK,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAIL,8BAA8B,EAC9B,SAAS,EAGV,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,uBAAuB,EAA4B,MAAM,mBAAmB,CAAC;AAGtF,MAAM,MAAM,oCAAoC,GAAG,UAAU,CAC3D,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;QAC7B,KAAK,EAAE,eAAe;QACtB,KAAK,EAAE,eAAe,GAAG,SAAS;KACnC,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,8BAA8B,CAAC,CAAC;CAChE,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,oCAAoC,GAAG,QAAQ,CACzD,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,SAAS,CAAC;IAC9D,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,UAAU,CAAC,8BAA8B,CAAC;CACpD,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iDAAiD,CAAC,OAAO,EAAE,aAAa,YAE5E,aAAa,iBACN,SAAS,eACX,SAAS,kBACN,qBAAqB,UAC7B,qBAAqB,WACpB,uBAAuB,UAcnC;;;;;;kFAOsD,OAAO,gBAAgB,WAAW;;;;;;;;;;;;;;;;AALzF,wBAsB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_MULTIAGGR.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMRangeSelectedLabelsMultiArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_MULTIAGGR_1 = require("./RANGE_MULTIAGGR");
+const MGET_1 = require("./MGET");
+/**
+ * Creates a function that parses arguments for multi-range commands with selected labels and multiple aggregators
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeSelectedLabelsMultiArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, selectedLabels, filter, options) => {
+        parser.push(command);
+        (0, RANGE_MULTIAGGR_1.parseRangeMultiArguments)(parser, fromTimestamp, toTimestamp, options);
+        (0, helpers_1.parseSelectedLabelsArguments)(parser, selectedLabels);
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    };
+}
+exports.createTransformMRangeSelectedLabelsMultiArguments = createTransformMRangeSelectedLabelsMultiArguments;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeSelectedLabelsMultiArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, labels, samples]) => {
+                return {
+                    labels: (0, helpers_1.transformRESP2Labels)(labels, typeMapping),
+                    samples: helpers_1.transformMultiAggregationSamplesReply[2](samples)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, _metadata, samples]) => {
+                return {
+                    labels,
+                    samples: helpers_1.transformMultiAggregationSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_SELECTED_LABELS_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_SELECTED_LABELS_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_SELECTED_LABELS_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_SELECTED_LABELS_MULTIAGGR.ts"],"names":[],"mappings":";;;AAGA,uCAQmB;AACnB,uDAAsF;AACtF,iCAA6C;AAsB7C;;;GAGG;AACH,SAAgB,iDAAiD,CAAC,OAAsB;IACtF,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,cAAqC,EACrC,MAA6B,EAC7B,OAAgC,EAChC,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,0CAAwB,EACtB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,IAAA,sCAA4B,EAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAErD,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AArBD,8GAqBC;AAED,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,iDAAiD,CAAC,WAAW,CAAC;IAC5E,cAAc,EAAE;QACd,CAAC,CAAC,KAA2C,EAAE,CAAW,EAAE,WAAyB;YACnF,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;gBACxD,OAAO;oBACL,MAAM,EAAE,IAAA,8BAAoB,EAAC,MAAM,EAAE,WAAW,CAAC;oBACjD,OAAO,EAAE,+CAAqC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3D,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAA2C;YAC3C,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBAC7D,OAAO;oBACL,MAAM;oBACN,OAAO,EAAE,+CAAqC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3D,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, NullReply, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport {\n  parseSelectedLabelsArguments,\n  resp2MapToValue,\n  resp3MapToValue,\n  MultiAggregationSampleRawReply,\n  Timestamp,\n  transformRESP2Labels,\n  transformMultiAggregationSamplesReply\n} from './helpers';\nimport { TsRangeMultiAggrOptions, parseRangeMultiArguments } from './RANGE_MULTIAGGR';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeSelectedLabelsMultiRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: ArrayReply<TuplesReply<[\n      label: BlobStringReply,\n      value: BlobStringReply | NullReply\n    ]>>,\n    samples: ArrayReply<Resp2Reply<MultiAggregationSampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeSelectedLabelsMultiRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, BlobStringReply | NullReply>,\n    metadata: never, // ?!\n    samples: ArrayReply<MultiAggregationSampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands with selected labels and multiple aggregators\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createTransformMRangeSelectedLabelsMultiArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    selectedLabels: RedisVariadicArgument,\n    filter: RedisVariadicArgument,\n    options: TsRangeMultiAggrOptions\n  ) => {\n    parser.push(command);\n    parseRangeMultiArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n\n    parseSelectedLabelsArguments(parser, selectedLabels);\n\n    parseFilterArgument(parser, filter);\n  };\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand: createTransformMRangeSelectedLabelsMultiArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, labels, samples]) => {\n        return {\n          labels: transformRESP2Labels(labels, typeMapping),\n          samples: transformMultiAggregationSamplesReply[2](samples)\n        };\n      }, typeMapping);\n    },\n    3(reply: TsMRangeSelectedLabelsMultiRawReply3) {\n      return resp3MapToValue(reply, ([labels, _metadata, samples]) => {\n        return {\n          labels,\n          samples: transformMultiAggregationSamplesReply[3](samples)\n        };\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS.d.ts

@@ -0,0 +1,46 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { SampleRawReply, Timestamp } from './helpers';
+import { TsRangeOptions } from './RANGE';
+export type TsMRangeWithLabelsRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: ArrayReply<TuplesReply<[
+        label: BlobStringReply,
+        value: BlobStringReply
+    ]>>,
+    samples: ArrayReply<Resp2Reply<SampleRawReply>>
+]>>;
+export type TsMRangeWithLabelsRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, BlobStringReply>,
+    metadata: never,
+    samples: ArrayReply<SampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with labels
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeWithLabelsArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsRangeOptions) => void;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            labels: Record<string, BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeWithLabelsRawReply3) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_WITHLABELS.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_WITHLABELS.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_WITHLABELS.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAwB,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACrK,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAoC,cAAc,EAAE,SAAS,EAAyB,MAAM,WAAW,CAAC;AAC/G,OAAO,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAG9D,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAClD,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;QAC7B,KAAK,EAAE,eAAe;QACtB,KAAK,EAAE,eAAe;KACvB,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;CAChD,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAChD,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAClD,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC;CACpC,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,wCAAwC,CAAC,OAAO,EAAE,aAAa,YAEnE,aAAa,iBACN,SAAS,eACX,SAAS,UACd,qBAAqB,YACnB,cAAc,UAc3B;;;;;;yEAO6C,OAAO,gBAAgB,WAAW;;;;;;;;;;;;;;;;AALhF,wBA+B6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMRangeWithLabelsArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_1 = require("./RANGE");
+const MGET_1 = require("./MGET");
+/**
+ * Creates a function that parses arguments for multi-range commands with labels
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeWithLabelsArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, filter, options) => {
+        parser.push(command);
+        (0, RANGE_1.parseRangeArguments)(parser, fromTimestamp, toTimestamp, options);
+        parser.push('WITHLABELS');
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    };
+}
+exports.createTransformMRangeWithLabelsArguments = createTransformMRangeWithLabelsArguments;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeWithLabelsArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, labels, samples]) => {
+                const unwrappedLabels = labels;
+                // TODO: use Map type mapping for labels
+                const labelsObject = {};
+                for (const tuple of unwrappedLabels) {
+                    const [key, value] = tuple;
+                    const unwrappedKey = key;
+                    labelsObject[unwrappedKey.toString()] = value;
+                }
+                return {
+                    labels: labelsObject,
+                    samples: helpers_1.transformSamplesReply[2](samples)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, _metadata, samples]) => {
+                return {
+                    labels,
+                    samples: helpers_1.transformSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_WITHLABELS.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_WITHLABELS.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_WITHLABELS.ts"],"names":[],"mappings":";;;AAGA,uCAA+G;AAC/G,mCAA8D;AAC9D,iCAA6C;AAsB7C;;;GAGG;AACH,SAAgB,wCAAwC,CAAC,OAAsB;IAC7E,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,MAA6B,EAC7B,OAAwB,EACxB,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,2BAAmB,EACjB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAE1B,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AApBD,4FAoBC;AAED,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,wCAAwC,CAAC,WAAW,CAAC;IACnE,cAAc,EAAE;QACd,CAAC,CAAC,KAAkC,EAAE,CAAW,EAAE,WAAyB;YAC1E,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;gBACxD,MAAM,eAAe,GAAG,MAA+C,CAAC;gBACxE,wCAAwC;gBACxC,MAAM,YAAY,GAAoC,EAAE,CAAC;gBACzD,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE,CAAC;oBACpC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,KAA6C,CAAC;oBACnE,MAAM,YAAY,GAAG,GAAyC,CAAC;oBAC/D,YAAY,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,KAAK,CAAC;gBAChD,CAAC;gBAED,OAAO;oBACL,MAAM,EAAE,YAAY;oBACpB,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAAkC;YAClC,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBAC7D,OAAO;oBACL,MAAM;oBACN,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, UnwrapReply, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { resp2MapToValue, resp3MapToValue, SampleRawReply, Timestamp, transformSamplesReply } from './helpers';\nimport { TsRangeOptions, parseRangeArguments } from './RANGE';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeWithLabelsRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: ArrayReply<TuplesReply<[\n      label: BlobStringReply,\n      value: BlobStringReply\n    ]>>,\n    samples: ArrayReply<Resp2Reply<SampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeWithLabelsRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, BlobStringReply>,\n    metadata: never, // ?!\n    samples: ArrayReply<SampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands with labels\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createTransformMRangeWithLabelsArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    filter: RedisVariadicArgument,\n    options?: TsRangeOptions\n  ) => {\n    parser.push(command);\n    parseRangeArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n\n    parser.push('WITHLABELS');\n\n    parseFilterArgument(parser, filter);\n  };\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand: createTransformMRangeWithLabelsArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, labels, samples]) => {\n        const unwrappedLabels = labels as unknown as UnwrapReply<typeof labels>;\n        // TODO: use Map type mapping for labels\n        const labelsObject: Record<string, BlobStringReply> = {};\n        for (const tuple of unwrappedLabels) {\n          const [key, value] = tuple as unknown as UnwrapReply<typeof tuple>;\n          const unwrappedKey = key as unknown as UnwrapReply<typeof key>;\n          labelsObject[unwrappedKey.toString()] = value;\n        }\n\n        return {\n          labels: labelsObject,\n          samples: transformSamplesReply[2](samples)\n        };\n      }, typeMapping);\n    },\n    3(reply: TsMRangeWithLabelsRawReply3) {\n      return resp3MapToValue(reply, ([labels, _metadata, samples]) => {\n        return {\n          labels,\n          samples: transformSamplesReply[3](samples)\n        };\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_GROUPBY.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { SampleRawReply, Timestamp } from './helpers';
+import { TsRangeOptions } from './RANGE';
+import { TsMRangeGroupBy, TsMRangeGroupByRawMetadataReply3 } from './MRANGE_GROUPBY';
+export type TsMRangeWithLabelsGroupByRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: ArrayReply<TuplesReply<[
+        label: BlobStringReply,
+        value: BlobStringReply
+    ]>>,
+    samples: ArrayReply<Resp2Reply<SampleRawReply>>
+]>>;
+export type TsMRangeWithLabelsGroupByRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, BlobStringReply>,
+    metadata: never,
+    metadata2: TsMRangeGroupByRawMetadataReply3,
+    samples: ArrayReply<SampleRawReply>
+]>>;
+export declare function createMRangeWithLabelsGroupByTransformArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, groupBy: TsMRangeGroupBy, options?: TsRangeOptions) => void;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, groupBy: TsMRangeGroupBy, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
+            sources: string[] | Buffer[];
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeWithLabelsGroupByRawReply3) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
+            sources: ArrayReply<BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_WITHLABELS_GROUPBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_GROUPBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_WITHLABELS_GROUPBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_WITHLABELS_GROUPBY.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAW,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACxJ,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAoC,cAAc,EAAE,SAAS,EAA0D,MAAM,WAAW,CAAC;AAChJ,OAAO,EAAE,cAAc,EAAuB,MAAM,SAAS,CAAC;AAC9D,OAAO,EAAoD,eAAe,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAC;AAGvI,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;QAC7B,KAAK,EAAE,eAAe;QACtB,KAAK,EAAE,eAAe;KACvB,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;CAChD,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG,QAAQ,CACvD,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAClD,QAAQ,EAAE,KAAK;IACf,SAAS,EAAE,gCAAgC;IAC3C,OAAO,EAAE,UAAU,CAAC,cAAc,CAAC;CACpC,CAAC,CACH,CAAC;AAEF,wBAAgB,+CAA+C,CAAC,OAAO,EAAE,aAAa,YAE1E,aAAa,iBACN,SAAS,eACX,SAAS,UACd,qBAAqB,WACpB,eAAe,YACd,cAAc,UAgB3B;;;;;gFAMoD,OAAO,gBAAgB,WAAW;;;;;;;;;;;;;;;;;;AAJvF,wBAwB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_GROUPBY.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMRangeWithLabelsGroupByTransformArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_1 = require("./RANGE");
+const MRANGE_GROUPBY_1 = require("./MRANGE_GROUPBY");
+const MGET_1 = require("./MGET");
+function createMRangeWithLabelsGroupByTransformArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, filter, groupBy, options) => {
+        parser.push(command);
+        (0, RANGE_1.parseRangeArguments)(parser, fromTimestamp, toTimestamp, options);
+        parser.push('WITHLABELS');
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+        (0, MRANGE_GROUPBY_1.parseGroupByArguments)(parser, groupBy);
+    };
+}
+exports.createMRangeWithLabelsGroupByTransformArguments = createMRangeWithLabelsGroupByTransformArguments;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand: createMRangeWithLabelsGroupByTransformArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, labels, samples]) => {
+                const transformed = (0, helpers_1.transformRESP2LabelsWithSources)(labels);
+                return {
+                    labels: transformed.labels,
+                    sources: transformed.sources,
+                    samples: helpers_1.transformSamplesReply[2](samples)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, _metadata, metadata2, samples]) => {
+                return {
+                    labels,
+                    sources: (0, MRANGE_GROUPBY_1.extractResp3MRangeSources)(metadata2),
+                    samples: helpers_1.transformSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_WITHLABELS_GROUPBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_GROUPBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_WITHLABELS_GROUPBY.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_WITHLABELS_GROUPBY.ts"],"names":[],"mappings":";;;AAGA,uCAAgJ;AAChJ,mCAA8D;AAC9D,qDAAuI;AACvI,iCAA6C;AAuB7C,SAAgB,+CAA+C,CAAC,OAAsB;IACpF,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,MAA6B,EAC7B,OAAwB,EACxB,OAAwB,EACxB,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,2BAAmB,EACjB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAE1B,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAEpC,IAAA,sCAAqB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,CAAC,CAAC;AACN,CAAC;AAvBD,0GAuBC;AAED,kBAAe;IACb,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,+CAA+C,CAAC,WAAW,CAAC;IAC1E,cAAc,EAAE;QACd,CAAC,CAAC,KAAyC,EAAE,CAAW,EAAE,WAAyB;YACjF,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;gBACxD,MAAM,WAAW,GAAG,IAAA,yCAA+B,EAAC,MAAM,CAAC,CAAC;gBAC5D,OAAO;oBACL,MAAM,EAAE,WAAW,CAAC,MAAM;oBAC1B,OAAO,EAAE,WAAW,CAAC,OAAO;oBAC5B,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAAyC;YACzC,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBACxE,OAAO;oBACL,MAAM;oBACN,OAAO,EAAE,IAAA,0CAAyB,EAAC,SAAS,CAAC;oBAC7C,OAAO,EAAE,+BAAqB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3C,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport { resp2MapToValue, resp3MapToValue, SampleRawReply, Timestamp, transformRESP2LabelsWithSources, transformSamplesReply } from './helpers';\nimport { TsRangeOptions, parseRangeArguments } from './RANGE';\nimport { extractResp3MRangeSources, parseGroupByArguments, TsMRangeGroupBy, TsMRangeGroupByRawMetadataReply3 } from './MRANGE_GROUPBY';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeWithLabelsGroupByRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: ArrayReply<TuplesReply<[\n      label: BlobStringReply,\n      value: BlobStringReply\n    ]>>,\n    samples: ArrayReply<Resp2Reply<SampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeWithLabelsGroupByRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, BlobStringReply>,\n    metadata: never, // ?!\n    metadata2: TsMRangeGroupByRawMetadataReply3,\n    samples: ArrayReply<SampleRawReply>\n  ]>\n>;\n\nexport function createMRangeWithLabelsGroupByTransformArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    filter: RedisVariadicArgument,\n    groupBy: TsMRangeGroupBy,\n    options?: TsRangeOptions\n  ) => {\n    parser.push(command);\n    parseRangeArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n  \n    parser.push('WITHLABELS');\n  \n    parseFilterArgument(parser, filter);\n  \n    parseGroupByArguments(parser, groupBy);\n    };\n}\n\nexport default {\n  IS_READ_ONLY: true,\n  parseCommand: createMRangeWithLabelsGroupByTransformArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, labels, samples]) => {\n        const transformed = transformRESP2LabelsWithSources(labels);\n        return {\n          labels: transformed.labels,\n          sources: transformed.sources,\n          samples: transformSamplesReply[2](samples)\n        };\n      }, typeMapping);\n    },\n    3(reply: TsMRangeWithLabelsGroupByRawReply3) {\n      return resp3MapToValue(reply, ([labels, _metadata, metadata2, samples]) => {\n        return {\n          labels,\n          sources: extractResp3MRangeSources(metadata2),\n          samples: transformSamplesReply[3](samples)\n        };\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_MULTIAGGR.d.ts

@@ -0,0 +1,46 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { MultiAggregationSampleRawReply, Timestamp } from './helpers';
+import { TsRangeMultiAggrOptions } from './RANGE_MULTIAGGR';
+export type TsMRangeWithLabelsMultiRawReply2 = ArrayReply<TuplesReply<[
+    key: BlobStringReply,
+    labels: ArrayReply<TuplesReply<[
+        label: BlobStringReply,
+        value: BlobStringReply
+    ]>>,
+    samples: ArrayReply<Resp2Reply<MultiAggregationSampleRawReply>>
+]>>;
+export type TsMRangeWithLabelsMultiRawReply3 = MapReply<BlobStringReply, TuplesReply<[
+    labels: MapReply<BlobStringReply, BlobStringReply>,
+    metadata: never,
+    samples: ArrayReply<MultiAggregationSampleRawReply>
+]>>;
+/**
+ * Creates a function that parses arguments for multi-range commands with labels and multiple aggregators
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+export declare function createTransformMRangeWithLabelsMultiArguments(command: RedisArgument): (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options: TsRangeMultiAggrOptions) => void;
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options: TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: TypeMapping) => MapReply<BlobStringReply<string>, {
+            labels: Record<string, BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+        }>;
+        readonly 3: (this: void, reply: TsMRangeWithLabelsMultiRawReply3) => MapReply<BlobStringReply<string>, {
+            labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MRANGE_WITHLABELS_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_WITHLABELS_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/MRANGE_WITHLABELS_MULTIAGGR.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAwB,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACrK,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAGL,8BAA8B,EAC9B,SAAS,EAEV,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,uBAAuB,EAA4B,MAAM,mBAAmB,CAAC;AAGtF,MAAM,MAAM,gCAAgC,GAAG,UAAU,CACvD,WAAW,CAAC;IACV,GAAG,EAAE,eAAe;IACpB,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;QAC7B,KAAK,EAAE,eAAe;QACtB,KAAK,EAAE,eAAe;KACvB,CAAC,CAAC;IACH,OAAO,EAAE,UAAU,CAAC,UAAU,CAAC,8BAA8B,CAAC,CAAC;CAChE,CAAC,CACH,CAAC;AAEF,MAAM,MAAM,gCAAgC,GAAG,QAAQ,CACrD,eAAe,EACf,WAAW,CAAC;IACV,MAAM,EAAE,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAClD,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,UAAU,CAAC,8BAA8B,CAAC;CACpD,CAAC,CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,6CAA6C,CAAC,OAAO,EAAE,aAAa,YAExE,aAAa,iBACN,SAAS,eACX,SAAS,UACd,qBAAqB,WACpB,uBAAuB,UAcnC;;;;;;8EAOkD,OAAO,gBAAgB,WAAW;;;;;;;;;;;;;;;;AALrF,wBA+B6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_MULTIAGGR.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformMRangeWithLabelsMultiArguments = void 0;
+const helpers_1 = require("./helpers");
+const RANGE_MULTIAGGR_1 = require("./RANGE_MULTIAGGR");
+const MGET_1 = require("./MGET");
+/**
+ * Creates a function that parses arguments for multi-range commands with labels and multiple aggregators
+ * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)
+ */
+function createTransformMRangeWithLabelsMultiArguments(command) {
+    return (parser, fromTimestamp, toTimestamp, filter, options) => {
+        parser.push(command);
+        (0, RANGE_MULTIAGGR_1.parseRangeMultiArguments)(parser, fromTimestamp, toTimestamp, options);
+        parser.push('WITHLABELS');
+        (0, MGET_1.parseFilterArgument)(parser, filter);
+    };
+}
+exports.createTransformMRangeWithLabelsMultiArguments = createTransformMRangeWithLabelsMultiArguments;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand: createTransformMRangeWithLabelsMultiArguments('TS.MRANGE'),
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([_key, labels, samples]) => {
+                const unwrappedLabels = labels;
+                // TODO: use Map type mapping for labels
+                const labelsObject = {};
+                for (const tuple of unwrappedLabels) {
+                    const [key, value] = tuple;
+                    const unwrappedKey = key;
+                    labelsObject[unwrappedKey.toString()] = value;
+                }
+                return {
+                    labels: labelsObject,
+                    samples: helpers_1.transformMultiAggregationSamplesReply[2](samples)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([labels, _metadata, samples]) => {
+                return {
+                    labels,
+                    samples: helpers_1.transformMultiAggregationSamplesReply[3](samples)
+                };
+            });
+        }
+    },
+};
+//# sourceMappingURL=MRANGE_WITHLABELS_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MRANGE_WITHLABELS_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MRANGE_WITHLABELS_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/MRANGE_WITHLABELS_MULTIAGGR.ts"],"names":[],"mappings":";;;AAGA,uCAMmB;AACnB,uDAAsF;AACtF,iCAA6C;AAsB7C;;;GAGG;AACH,SAAgB,6CAA6C,CAAC,OAAsB;IAClF,OAAO,CACL,MAAqB,EACrB,aAAwB,EACxB,WAAsB,EACtB,MAA6B,EAC7B,OAAgC,EAChC,EAAE;QACF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrB,IAAA,0CAAwB,EACtB,MAAM,EACN,aAAa,EACb,WAAW,EACX,OAAO,CACR,CAAC;QAEF,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAE1B,IAAA,0BAAmB,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC,CAAC;AACJ,CAAC;AApBD,sGAoBC;AAED,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,EAAE,6CAA6C,CAAC,WAAW,CAAC;IACxE,cAAc,EAAE;QACd,CAAC,CAAC,KAAuC,EAAE,CAAW,EAAE,WAAyB;YAC/E,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE;gBACxD,MAAM,eAAe,GAAG,MAA+C,CAAC;gBACxE,wCAAwC;gBACxC,MAAM,YAAY,GAAoC,EAAE,CAAC;gBACzD,KAAK,MAAM,KAAK,IAAI,eAAe,EAAE,CAAC;oBACpC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,KAA6C,CAAC;oBACnE,MAAM,YAAY,GAAG,GAAyC,CAAC;oBAC/D,YAAY,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,KAAK,CAAC;gBAChD,CAAC;gBAED,OAAO;oBACL,MAAM,EAAE,YAAY;oBACpB,OAAO,EAAE,+CAAqC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3D,CAAC;YACJ,CAAC,EAAE,WAAW,CAAC,CAAC;QAClB,CAAC;QACD,CAAC,CAAC,KAAuC;YACvC,OAAO,IAAA,yBAAe,EAAC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE;gBAC7D,OAAO;oBACL,MAAM;oBACN,OAAO,EAAE,+CAAqC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;iBAC3D,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;KACF;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { Command, UnwrapReply, ArrayReply, BlobStringReply, Resp2Reply, MapReply, TuplesReply, TypeMapping, RedisArgument } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\nimport {\n  resp2MapToValue,\n  resp3MapToValue,\n  MultiAggregationSampleRawReply,\n  Timestamp,\n  transformMultiAggregationSamplesReply\n} from './helpers';\nimport { TsRangeMultiAggrOptions, parseRangeMultiArguments } from './RANGE_MULTIAGGR';\nimport { parseFilterArgument } from './MGET';\n\nexport type TsMRangeWithLabelsMultiRawReply2 = ArrayReply<\n  TuplesReply<[\n    key: BlobStringReply,\n    labels: ArrayReply<TuplesReply<[\n      label: BlobStringReply,\n      value: BlobStringReply\n    ]>>,\n    samples: ArrayReply<Resp2Reply<MultiAggregationSampleRawReply>>\n  ]>\n>;\n\nexport type TsMRangeWithLabelsMultiRawReply3 = MapReply<\n  BlobStringReply,\n  TuplesReply<[\n    labels: MapReply<BlobStringReply, BlobStringReply>,\n    metadata: never, // ?!\n    samples: ArrayReply<MultiAggregationSampleRawReply>\n  ]>\n>;\n\n/**\n * Creates a function that parses arguments for multi-range commands with labels and multiple aggregators\n * @param command - The command name to use (TS.MRANGE or TS.MREVRANGE)\n */\nexport function createTransformMRangeWithLabelsMultiArguments(command: RedisArgument) {\n  return (\n    parser: CommandParser,\n    fromTimestamp: Timestamp,\n    toTimestamp: Timestamp,\n    filter: RedisVariadicArgument,\n    options: TsRangeMultiAggrOptions\n  ) => {\n    parser.push(command);\n    parseRangeMultiArguments(\n      parser,\n      fromTimestamp,\n      toTimestamp,\n      options\n    );\n\n    parser.push('WITHLABELS');\n\n    parseFilterArgument(parser, filter);\n  };\n}\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand: createTransformMRangeWithLabelsMultiArguments('TS.MRANGE'),\n  transformReply: {\n    2(reply: TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: TypeMapping) {\n      return resp2MapToValue(reply, ([_key, labels, samples]) => {\n        const unwrappedLabels = labels as unknown as UnwrapReply<typeof labels>;\n        // TODO: use Map type mapping for labels\n        const labelsObject: Record<string, BlobStringReply> = {};\n        for (const tuple of unwrappedLabels) {\n          const [key, value] = tuple as unknown as UnwrapReply<typeof tuple>;\n          const unwrappedKey = key as unknown as UnwrapReply<typeof key>;\n          labelsObject[unwrappedKey.toString()] = value;\n        }\n\n        return {\n          labels: labelsObject,\n          samples: transformMultiAggregationSamplesReply[2](samples)\n        };\n      }, typeMapping);\n    },\n    3(reply: TsMRangeWithLabelsMultiRawReply3) {\n      return resp3MapToValue(reply, ([labels, _metadata, samples]) => {\n        return {\n          labels,\n          samples: transformMultiAggregationSamplesReply[3](samples)\n        };\n      });\n    }\n  },\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE").TsMRangeRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: number;
+        }[]>;
+        readonly 3: (this: void, reply: import("./MRANGE").TsMRangeRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+        }[]>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAGA,wBAK6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE.js

@@ -0,0 +1,33 @@
+"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 MRANGE_1 = __importStar(require("./MRANGE"));
+exports.default = {
+    NOT_KEYED_COMMAND: MRANGE_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: MRANGE_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_1.createTransformMRangeArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,mDAAkE;AAElE,kBAAe;IACb,iBAAiB,EAAE,gBAAM,CAAC,iBAAiB;IAC3C,YAAY,EAAE,gBAAM,CAAC,YAAY;IACjC,YAAY,EAAE,IAAA,uCAA8B,EAAC,cAAc,CAAC;IAC5D,cAAc,EAAE,gBAAM,CAAC,cAAc;CACX,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE, { createTransformMRangeArguments } from './MRANGE';\n\nexport default {\n  NOT_KEYED_COMMAND: MRANGE.NOT_KEYED_COMMAND,\n  IS_READ_ONLY: MRANGE.IS_READ_ONLY,\n  parseCommand: createTransformMRangeArguments('TS.MREVRANGE'),\n  transformReply: MRANGE.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_GROUPBY.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_GROUPBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_GROUPBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_GROUPBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_GROUPBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA,wBAI6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_GROUPBY.js

@@ -0,0 +1,32 @@
+"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 MRANGE_GROUPBY_1 = __importStar(require("./MRANGE_GROUPBY"));
+exports.default = {
+    IS_READ_ONLY: MRANGE_GROUPBY_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_GROUPBY_1.createTransformMRangeGroupByArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_GROUPBY_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_GROUPBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_GROUPBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_GROUPBY.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_GROUPBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,mEAAyF;AAEzF,kBAAe;IACb,YAAY,EAAE,wBAAc,CAAC,YAAY;IACzC,YAAY,EAAE,IAAA,sDAAqC,EAAC,cAAc,CAAC;IACnE,cAAc,EAAE,wBAAc,CAAC,cAAc;CACnB,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_GROUPBY, { createTransformMRangeGroupByArguments } from './MRANGE_GROUPBY';\n\nexport default {\n  IS_READ_ONLY: MRANGE_GROUPBY.IS_READ_ONLY,\n  parseCommand: createTransformMRangeGroupByArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_GROUPBY.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_MULTIAGGR.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: number[];
+        }[]>;
+        readonly 3: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+        }[]>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAGA,wBAK6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_MULTIAGGR.js

@@ -0,0 +1,33 @@
+"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 MRANGE_MULTIAGGR_1 = __importStar(require("./MRANGE_MULTIAGGR"));
+exports.default = {
+    NOT_KEYED_COMMAND: MRANGE_MULTIAGGR_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: MRANGE_MULTIAGGR_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_MULTIAGGR_1.createTransformMRangeMultiArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_MULTIAGGR_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,uEAA2F;AAE3F,kBAAe;IACb,iBAAiB,EAAE,0BAAgB,CAAC,iBAAiB;IACrD,YAAY,EAAE,0BAAgB,CAAC,YAAY;IAC3C,YAAY,EAAE,IAAA,sDAAmC,EAAC,cAAc,CAAC;IACjE,cAAc,EAAE,0BAAgB,CAAC,cAAc;CACrB,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_MULTIAGGR, { createTransformMRangeMultiArguments } from './MRANGE_MULTIAGGR';\n\nexport default {\n  NOT_KEYED_COMMAND: MRANGE_MULTIAGGR.NOT_KEYED_COMMAND,\n  IS_READ_ONLY: MRANGE_MULTIAGGR.IS_READ_ONLY,\n  parseCommand: createTransformMRangeMultiArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_MULTIAGGR.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_SELECTED_LABELS.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_SELECTED_LABELS.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_SELECTED_LABELS.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,wBAI6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS.js

@@ -0,0 +1,32 @@
+"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 MRANGE_SELECTED_LABELS_1 = __importStar(require("./MRANGE_SELECTED_LABELS"));
+exports.default = {
+    IS_READ_ONLY: MRANGE_SELECTED_LABELS_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_SELECTED_LABELS_1.createTransformMRangeSelectedLabelsArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_SELECTED_LABELS_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_SELECTED_LABELS.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_SELECTED_LABELS.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_SELECTED_LABELS.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,mFAAgH;AAEhH,kBAAe;IACb,YAAY,EAAE,gCAAsB,CAAC,YAAY;IACjD,YAAY,EAAE,IAAA,qEAA4C,EAAC,cAAc,CAAC;IAC1E,cAAc,EAAE,gCAAsB,CAAC,cAAc;CAC3B,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_SELECTED_LABELS, { createTransformMRangeSelectedLabelsArguments } from './MRANGE_SELECTED_LABELS';\n\nexport default {\n  IS_READ_ONLY: MRANGE_SELECTED_LABELS.IS_READ_ONLY,\n  parseCommand: createTransformMRangeSelectedLabelsArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_SELECTED_LABELS.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_GROUPBY.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_SELECTED_LABELS_GROUPBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_GROUPBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_SELECTED_LABELS_GROUPBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_SELECTED_LABELS_GROUPBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAGA,wBAI6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_GROUPBY.js

@@ -0,0 +1,32 @@
+"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 MRANGE_SELECTED_LABELS_GROUPBY_1 = __importStar(require("./MRANGE_SELECTED_LABELS_GROUPBY"));
+exports.default = {
+    IS_READ_ONLY: MRANGE_SELECTED_LABELS_GROUPBY_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_SELECTED_LABELS_GROUPBY_1.createMRangeSelectedLabelsGroupByTransformArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_SELECTED_LABELS_GROUPBY_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_SELECTED_LABELS_GROUPBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_GROUPBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_SELECTED_LABELS_GROUPBY.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_SELECTED_LABELS_GROUPBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,mGAAuI;AAEvI,kBAAe;IACb,YAAY,EAAE,wCAA8B,CAAC,YAAY;IACzD,YAAY,EAAE,IAAA,oFAAmD,EAAC,cAAc,CAAC;IACjF,cAAc,EAAE,wCAA8B,CAAC,cAAc;CACnC,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_SELECTED_LABELS_GROUPBY, { createMRangeSelectedLabelsGroupByTransformArguments } from './MRANGE_SELECTED_LABELS_GROUPBY';\n\nexport default {\n  IS_READ_ONLY: MRANGE_SELECTED_LABELS_GROUPBY.IS_READ_ONLY,\n  parseCommand: createMRangeSelectedLabelsGroupByTransformArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_SELECTED_LABELS_GROUPBY.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_MULTIAGGR.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_SELECTED_LABELS_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_SELECTED_LABELS_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_SELECTED_LABELS_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAGA,wBAK6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_MULTIAGGR.js

@@ -0,0 +1,33 @@
+"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 MRANGE_SELECTED_LABELS_MULTIAGGR_1 = __importStar(require("./MRANGE_SELECTED_LABELS_MULTIAGGR"));
+exports.default = {
+    NOT_KEYED_COMMAND: MRANGE_SELECTED_LABELS_MULTIAGGR_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: MRANGE_SELECTED_LABELS_MULTIAGGR_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_SELECTED_LABELS_MULTIAGGR_1.createTransformMRangeSelectedLabelsMultiArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_SELECTED_LABELS_MULTIAGGR_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_SELECTED_LABELS_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_SELECTED_LABELS_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_SELECTED_LABELS_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_SELECTED_LABELS_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,uGAAyI;AAEzI,kBAAe;IACb,iBAAiB,EAAE,0CAAgC,CAAC,iBAAiB;IACrE,YAAY,EAAE,0CAAgC,CAAC,YAAY;IAC3D,YAAY,EAAE,IAAA,oFAAiD,EAAC,cAAc,CAAC;IAC/E,cAAc,EAAE,0CAAgC,CAAC,cAAc;CACrC,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_SELECTED_LABELS_MULTIAGGR, { createTransformMRangeSelectedLabelsMultiArguments } from './MRANGE_SELECTED_LABELS_MULTIAGGR';\n\nexport default {\n  NOT_KEYED_COMMAND: MRANGE_SELECTED_LABELS_MULTIAGGR.NOT_KEYED_COMMAND,\n  IS_READ_ONLY: MRANGE_SELECTED_LABELS_MULTIAGGR.IS_READ_ONLY,\n  parseCommand: createTransformMRangeSelectedLabelsMultiArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_SELECTED_LABELS_MULTIAGGR.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_WITHLABELS.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_WITHLABELS.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_WITHLABELS.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAGA,wBAK6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS.js

@@ -0,0 +1,33 @@
+"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 MRANGE_WITHLABELS_1 = __importStar(require("./MRANGE_WITHLABELS"));
+exports.default = {
+    NOT_KEYED_COMMAND: MRANGE_WITHLABELS_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: MRANGE_WITHLABELS_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_WITHLABELS_1.createTransformMRangeWithLabelsArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_WITHLABELS_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_WITHLABELS.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_WITHLABELS.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_WITHLABELS.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,yEAAkG;AAElG,kBAAe;IACb,iBAAiB,EAAE,2BAAiB,CAAC,iBAAiB;IACtD,YAAY,EAAE,2BAAiB,CAAC,YAAY;IAC5C,YAAY,EAAE,IAAA,4DAAwC,EAAC,cAAc,CAAC;IACtE,cAAc,EAAE,2BAAiB,CAAC,cAAc;CACtB,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_WITHLABELS, { createTransformMRangeWithLabelsArguments } from './MRANGE_WITHLABELS';\n\nexport default {\n  NOT_KEYED_COMMAND: MRANGE_WITHLABELS.NOT_KEYED_COMMAND,\n  IS_READ_ONLY: MRANGE_WITHLABELS.IS_READ_ONLY,\n  parseCommand: createTransformMRangeWithLabelsArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_WITHLABELS.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_GROUPBY.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            sources: string[] | Buffer[];
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            sources: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_WITHLABELS_GROUPBY.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_GROUPBY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_WITHLABELS_GROUPBY.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_WITHLABELS_GROUPBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAI6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_GROUPBY.js

@@ -0,0 +1,32 @@
+"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 MRANGE_WITHLABELS_GROUPBY_1 = __importStar(require("./MRANGE_WITHLABELS_GROUPBY"));
+exports.default = {
+    IS_READ_ONLY: MRANGE_WITHLABELS_GROUPBY_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_WITHLABELS_GROUPBY_1.createMRangeWithLabelsGroupByTransformArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_WITHLABELS_GROUPBY_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_WITHLABELS_GROUPBY.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_GROUPBY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_WITHLABELS_GROUPBY.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_WITHLABELS_GROUPBY.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,yFAAyH;AAEzH,kBAAe;IACb,YAAY,EAAE,mCAAyB,CAAC,YAAY;IACpD,YAAY,EAAE,IAAA,2EAA+C,EAAC,cAAc,CAAC;IAC7E,cAAc,EAAE,mCAAyB,CAAC,cAAc;CAC9B,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_WITHLABELS_GROUPBY, { createMRangeWithLabelsGroupByTransformArguments } from './MRANGE_WITHLABELS_GROUPBY';\n\nexport default {\n  IS_READ_ONLY: MRANGE_WITHLABELS_GROUPBY.IS_READ_ONLY,\n  parseCommand: createMRangeWithLabelsGroupByTransformArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_WITHLABELS_GROUPBY.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_MULTIAGGR.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+        }>;
+        readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+            labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            samples: {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        }>;
+    };
+};
+export default _default;
+//# sourceMappingURL=MREVRANGE_WITHLABELS_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_WITHLABELS_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_WITHLABELS_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;AAGA,wBAK6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_MULTIAGGR.js

@@ -0,0 +1,33 @@
+"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 MRANGE_WITHLABELS_MULTIAGGR_1 = __importStar(require("./MRANGE_WITHLABELS_MULTIAGGR"));
+exports.default = {
+    NOT_KEYED_COMMAND: MRANGE_WITHLABELS_MULTIAGGR_1.default.NOT_KEYED_COMMAND,
+    IS_READ_ONLY: MRANGE_WITHLABELS_MULTIAGGR_1.default.IS_READ_ONLY,
+    parseCommand: (0, MRANGE_WITHLABELS_MULTIAGGR_1.createTransformMRangeWithLabelsMultiArguments)('TS.MREVRANGE'),
+    transformReply: MRANGE_WITHLABELS_MULTIAGGR_1.default.transformReply,
+};
+//# sourceMappingURL=MREVRANGE_WITHLABELS_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/MREVRANGE_WITHLABELS_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MREVRANGE_WITHLABELS_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/MREVRANGE_WITHLABELS_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,6FAA2H;AAE3H,kBAAe;IACb,iBAAiB,EAAE,qCAA2B,CAAC,iBAAiB;IAChE,YAAY,EAAE,qCAA2B,CAAC,YAAY;IACtD,YAAY,EAAE,IAAA,2EAA6C,EAAC,cAAc,CAAC;IAC3E,cAAc,EAAE,qCAA2B,CAAC,cAAc;CAChC,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport MRANGE_WITHLABELS_MULTIAGGR, { createTransformMRangeWithLabelsMultiArguments } from './MRANGE_WITHLABELS_MULTIAGGR';\n\nexport default {\n  NOT_KEYED_COMMAND: MRANGE_WITHLABELS_MULTIAGGR.NOT_KEYED_COMMAND,\n  IS_READ_ONLY: MRANGE_WITHLABELS_MULTIAGGR.IS_READ_ONLY,\n  parseCommand: createTransformMRangeWithLabelsMultiArguments('TS.MREVRANGE'),\n  transformReply: MRANGE_WITHLABELS_MULTIAGGR.transformReply,\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/QUERYINDEX.d.ts

@@ -0,0 +1,14 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { ArrayReply, BlobStringReply, SetReply } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+declare const _default: {
+    readonly NOT_KEYED_COMMAND: true;
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, filter: RedisVariadicArgument) => void;
+    readonly transformReply: {
+        readonly 2: () => ArrayReply<BlobStringReply>;
+        readonly 3: () => SetReply<BlobStringReply>;
+    };
+};
+export default _default;
+//# sourceMappingURL=QUERYINDEX.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/QUERYINDEX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QUERYINDEX.d.ts","sourceRoot":"","sources":["../../../lib/commands/QUERYINDEX.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAW,MAAM,mCAAmC,CAAC;AACnG,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;;;;gDAKtE,aAAa,UAAU,qBAAqB;;0BAK9B,WAAW,eAAe,CAAC;0BAC3B,SAAS,eAAe,CAAC;;;AAT9D,wBAW6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/QUERYINDEX.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    parseCommand(parser, filter) {
+        parser.push('TS.QUERYINDEX');
+        parser.pushVariadic(filter);
+    },
+    transformReply: {
+        2: undefined,
+        3: undefined
+    }
+};
+//# sourceMappingURL=QUERYINDEX.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/QUERYINDEX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QUERYINDEX.js","sourceRoot":"","sources":["../../../lib/commands/QUERYINDEX.ts"],"names":[],"mappings":";;AAIA,kBAAe;IACb,iBAAiB,EAAE,IAAI;IACvB,YAAY,EAAE,IAAI;IAClB,YAAY,CAAC,MAAqB,EAAE,MAA6B;QAC/D,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC7B,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IACD,cAAc,EAAE;QACd,CAAC,EAAE,SAAyD;QAC5D,CAAC,EAAE,SAAuD;KAC3D;CACyB,CAAC","sourcesContent":["import { CommandParser } from '@redis/client/dist/lib/client/parser';\nimport { ArrayReply, BlobStringReply, SetReply, Command } from '@redis/client/dist/lib/RESP/types';\nimport { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';\n\nexport default {\n  NOT_KEYED_COMMAND: true,\n  IS_READ_ONLY: true,\n  parseCommand(parser: CommandParser, filter: RedisVariadicArgument) {\n    parser.push('TS.QUERYINDEX');\n    parser.pushVariadic(filter);\n  },\n  transformReply: {\n    2: undefined as unknown as () => ArrayReply<BlobStringReply>,\n    3: undefined as unknown as () => SetReply<BlobStringReply>\n  }\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/RANGE.d.ts

@@ -0,0 +1,45 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { Timestamp, SamplesRawReply } from './helpers';
+import { TimeSeriesAggregationType } from './CREATERULE';
+export declare const TIME_SERIES_BUCKET_TIMESTAMP: {
+    LOW: string;
+    MIDDLE: string;
+    END: string;
+};
+export type TimeSeriesBucketTimestamp = typeof TIME_SERIES_BUCKET_TIMESTAMP[keyof typeof TIME_SERIES_BUCKET_TIMESTAMP];
+export interface TsRangeOptions {
+    LATEST?: boolean;
+    FILTER_BY_TS?: Array<Timestamp>;
+    FILTER_BY_VALUE?: {
+        min: number;
+        max: number;
+    };
+    COUNT?: number;
+    ALIGN?: Timestamp;
+    AGGREGATION?: {
+        ALIGN?: Timestamp;
+        type: TimeSeriesAggregationType;
+        timeBucket: Timestamp;
+        BUCKETTIMESTAMP?: TimeSeriesBucketTimestamp;
+        EMPTY?: boolean;
+    };
+}
+export declare function parseRangeArguments(parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, options?: TsRangeOptions): void;
+export declare function transformRangeArguments(parser: CommandParser, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp, options?: TsRangeOptions): void;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp, options?: TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[]>) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: number;
+        }[];
+        readonly 3: (this: void, reply: SamplesRawReply) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=RANGE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/RANGE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RANGE.d.ts","sourceRoot":"","sources":["../../../lib/commands/RANGE.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAW,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,SAAS,EAA8B,eAAe,EAAyB,MAAM,WAAW,CAAC;AAC1G,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAGzD,eAAO,MAAM,4BAA4B;;;;CAIxC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,OAAO,4BAA4B,CAAC,MAAM,OAAO,4BAA4B,CAAC,CAAC;AAEvH,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAChC,eAAe,CAAC,EAAE;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,WAAW,CAAC,EAAE;QACZ,KAAK,CAAC,EAAE,SAAS,CAAC;QAClB,IAAI,EAAE,yBAAyB,CAAC;QAChC,UAAU,EAAE,SAAS,CAAC;QACtB,eAAe,CAAC,EAAE,yBAAyB,CAAC;QAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;CACH;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,SAAS,EACtB,OAAO,CAAC,EAAE,cAAc,QAoDzB;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,aAAa,EAClB,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,SAAS,EACtB,OAAO,CAAC,EAAE,cAAc,QAIzB;;;;;;;;;;;;;;;AAED,wBAgB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/RANGE.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRangeArguments = exports.parseRangeArguments = exports.TIME_SERIES_BUCKET_TIMESTAMP = void 0;
+const helpers_1 = require("./helpers");
+exports.TIME_SERIES_BUCKET_TIMESTAMP = {
+    LOW: '-',
+    MIDDLE: '~',
+    END: '+'
+};
+function parseRangeArguments(parser, fromTimestamp, toTimestamp, options) {
+    parser.push((0, helpers_1.transformTimestampArgument)(fromTimestamp), (0, helpers_1.transformTimestampArgument)(toTimestamp));
+    if (options?.LATEST) {
+        parser.push('LATEST');
+    }
+    if (options?.FILTER_BY_TS) {
+        parser.push('FILTER_BY_TS');
+        for (const timestamp of options.FILTER_BY_TS) {
+            parser.push((0, helpers_1.transformTimestampArgument)(timestamp));
+        }
+    }
+    if (options?.FILTER_BY_VALUE) {
+        parser.push('FILTER_BY_VALUE', options.FILTER_BY_VALUE.min.toString(), options.FILTER_BY_VALUE.max.toString());
+    }
+    if (options?.COUNT !== undefined) {
+        parser.push('COUNT', options.COUNT.toString());
+    }
+    if (options?.AGGREGATION) {
+        if (options?.ALIGN !== undefined) {
+            parser.push('ALIGN', (0, helpers_1.transformTimestampArgument)(options.ALIGN));
+        }
+        parser.push('AGGREGATION', options.AGGREGATION.type, (0, helpers_1.transformTimestampArgument)(options.AGGREGATION.timeBucket));
+        if (options.AGGREGATION.BUCKETTIMESTAMP) {
+            parser.push('BUCKETTIMESTAMP', options.AGGREGATION.BUCKETTIMESTAMP);
+        }
+        if (options.AGGREGATION.EMPTY) {
+            parser.push('EMPTY');
+        }
+    }
+}
+exports.parseRangeArguments = parseRangeArguments;
+function transformRangeArguments(parser, key, fromTimestamp, toTimestamp, options) {
+    parser.pushKey(key);
+    parseRangeArguments(parser, fromTimestamp, toTimestamp, options);
+}
+exports.transformRangeArguments = transformRangeArguments;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.RANGE');
+        transformRangeArguments(...args);
+    },
+    transformReply: {
+        2(reply) {
+            return helpers_1.transformSamplesReply[2](reply);
+        },
+        3(reply) {
+            return helpers_1.transformSamplesReply[3](reply);
+        }
+    }
+};
+//# sourceMappingURL=RANGE.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/RANGE_MULTIAGGR.d.ts

@@ -0,0 +1,40 @@
+import { CommandParser } from '@redis/client/dist/lib/client/parser';
+import { RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { Timestamp, MultiAggregationSamplesRawReply } from './helpers';
+import { TimeSeriesAggregationType } from './CREATERULE';
+import { TimeSeriesBucketTimestamp } from './RANGE';
+export type TimeSeriesAggregationTypeList = [TimeSeriesAggregationType, ...Array<TimeSeriesAggregationType>];
+export interface TsRangeMultiAggrOptions {
+    LATEST?: boolean;
+    FILTER_BY_TS?: Array<Timestamp>;
+    FILTER_BY_VALUE?: {
+        min: number;
+        max: number;
+    };
+    COUNT?: number;
+    ALIGN?: Timestamp;
+    AGGREGATION: {
+        types: TimeSeriesAggregationTypeList;
+        timeBucket: Timestamp;
+        BUCKETTIMESTAMP?: TimeSeriesBucketTimestamp;
+        EMPTY?: boolean;
+    };
+}
+export declare function parseRangeMultiArguments(parser: CommandParser, fromTimestamp: Timestamp, toTimestamp: Timestamp, options: TsRangeMultiAggrOptions): void;
+export declare function transformRangeMultiArguments(parser: CommandParser, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp, options: TsRangeMultiAggrOptions): void;
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: CommandParser, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp, options: TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[]>) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: number[];
+        }[];
+        readonly 3: (this: void, reply: MultiAggregationSamplesRawReply) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=RANGE_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/RANGE_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RANGE_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/RANGE_MULTIAGGR.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,aAAa,EAAW,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EACL,SAAS,EAET,+BAA+B,EAEhC,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,MAAM,6BAA6B,GAAG,CAAC,yBAAyB,EAAE,GAAG,KAAK,CAAC,yBAAyB,CAAC,CAAC,CAAC;AAE7G,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAChC,eAAe,CAAC,EAAE;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,WAAW,EAAE;QACX,KAAK,EAAE,6BAA6B,CAAC;QACrC,UAAU,EAAE,SAAS,CAAC;QACtB,eAAe,CAAC,EAAE,yBAAyB,CAAC;QAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;CACH;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,EACrB,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,SAAS,EACtB,OAAO,EAAE,uBAAuB,QAkDjC;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,aAAa,EAClB,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,SAAS,EACtB,OAAO,EAAE,uBAAuB,QAIjC;;;;;;;;;;;;;;;AAED,wBAgB6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/RANGE_MULTIAGGR.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRangeMultiArguments = exports.parseRangeMultiArguments = void 0;
+const helpers_1 = require("./helpers");
+function parseRangeMultiArguments(parser, fromTimestamp, toTimestamp, options) {
+    parser.push((0, helpers_1.transformTimestampArgument)(fromTimestamp), (0, helpers_1.transformTimestampArgument)(toTimestamp));
+    if (options.LATEST) {
+        parser.push('LATEST');
+    }
+    if (options.FILTER_BY_TS) {
+        parser.push('FILTER_BY_TS');
+        for (const timestamp of options.FILTER_BY_TS) {
+            parser.push((0, helpers_1.transformTimestampArgument)(timestamp));
+        }
+    }
+    if (options.FILTER_BY_VALUE) {
+        parser.push('FILTER_BY_VALUE', options.FILTER_BY_VALUE.min.toString(), options.FILTER_BY_VALUE.max.toString());
+    }
+    if (options.COUNT !== undefined) {
+        parser.push('COUNT', options.COUNT.toString());
+    }
+    if (options.ALIGN !== undefined) {
+        parser.push('ALIGN', (0, helpers_1.transformTimestampArgument)(options.ALIGN));
+    }
+    parser.push('AGGREGATION', options.AGGREGATION.types.join(','), (0, helpers_1.transformTimestampArgument)(options.AGGREGATION.timeBucket));
+    if (options.AGGREGATION.BUCKETTIMESTAMP) {
+        parser.push('BUCKETTIMESTAMP', options.AGGREGATION.BUCKETTIMESTAMP);
+    }
+    if (options.AGGREGATION.EMPTY) {
+        parser.push('EMPTY');
+    }
+}
+exports.parseRangeMultiArguments = parseRangeMultiArguments;
+function transformRangeMultiArguments(parser, key, fromTimestamp, toTimestamp, options) {
+    parser.pushKey(key);
+    parseRangeMultiArguments(parser, fromTimestamp, toTimestamp, options);
+}
+exports.transformRangeMultiArguments = transformRangeMultiArguments;
+exports.default = {
+    IS_READ_ONLY: true,
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.RANGE');
+        transformRangeMultiArguments(...args);
+    },
+    transformReply: {
+        2(reply) {
+            return helpers_1.transformMultiAggregationSamplesReply[2](reply);
+        },
+        3(reply) {
+            return helpers_1.transformMultiAggregationSamplesReply[3](reply);
+        }
+    }
+};
+//# sourceMappingURL=RANGE_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[]>) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: number;
+        }[];
+        readonly 3: (this: void, reply: import("./helpers").SamplesRawReply) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=REVRANGE.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"REVRANGE.d.ts","sourceRoot":"","sources":["../../../lib/commands/REVRANGE.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAGA,wBAS6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE.js

@@ -0,0 +1,36 @@
+"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 RANGE_1 = __importStar(require("./RANGE"));
+exports.default = {
+    IS_READ_ONLY: RANGE_1.default.IS_READ_ONLY,
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.REVRANGE');
+        (0, RANGE_1.transformRangeArguments)(...args);
+    },
+    transformReply: RANGE_1.default.transformReply
+};
+//# sourceMappingURL=REVRANGE.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"REVRANGE.js","sourceRoot":"","sources":["../../../lib/commands/REVRANGE.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,iDAAyD;AAEzD,kBAAe;IACb,YAAY,EAAE,eAAK,CAAC,YAAY;IAChC,YAAY,CAAC,GAAG,IAAgD;QAC9D,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvB,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC3B,IAAA,+BAAuB,EAAC,GAAG,IAAI,CAAC,CAAC;IACnC,CAAC;IACD,cAAc,EAAE,eAAK,CAAC,cAAc;CACV,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport RANGE, { transformRangeArguments } from './RANGE';\n\nexport default {\n  IS_READ_ONLY: RANGE.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof transformRangeArguments>) {\n    const parser = args[0];\n\n    parser.push('TS.REVRANGE');\n    transformRangeArguments(...args);\n  },\n  transformReply: RANGE.transformReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE_MULTIAGGR.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    readonly IS_READ_ONLY: true;
+    readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+    readonly transformReply: {
+        readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[]>) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: number[];
+        }[];
+        readonly 3: (this: void, reply: import("./helpers").MultiAggregationSamplesRawReply) => {
+            timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+            values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+        }[];
+    };
+};
+export default _default;
+//# sourceMappingURL=REVRANGE_MULTIAGGR.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE_MULTIAGGR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"REVRANGE_MULTIAGGR.d.ts","sourceRoot":"","sources":["../../../lib/commands/REVRANGE_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAGA,wBAS6B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE_MULTIAGGR.js

@@ -0,0 +1,36 @@
+"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 RANGE_MULTIAGGR_1 = __importStar(require("./RANGE_MULTIAGGR"));
+exports.default = {
+    IS_READ_ONLY: RANGE_MULTIAGGR_1.default.IS_READ_ONLY,
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.REVRANGE');
+        (0, RANGE_MULTIAGGR_1.transformRangeMultiArguments)(...args);
+    },
+    transformReply: RANGE_MULTIAGGR_1.default.transformReply
+};
+//# sourceMappingURL=REVRANGE_MULTIAGGR.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/REVRANGE_MULTIAGGR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"REVRANGE_MULTIAGGR.js","sourceRoot":"","sources":["../../../lib/commands/REVRANGE_MULTIAGGR.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,qEAAkF;AAElF,kBAAe;IACb,YAAY,EAAE,yBAAe,CAAC,YAAY;IAC1C,YAAY,CAAC,GAAG,IAAqD;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QAEvB,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC3B,IAAA,8CAA4B,EAAC,GAAG,IAAI,CAAC,CAAC;IACxC,CAAC;IACD,cAAc,EAAE,yBAAe,CAAC,cAAc;CACpB,CAAC","sourcesContent":["import { Command } from '@redis/client/dist/lib/RESP/types';\nimport RANGE_MULTIAGGR, { transformRangeMultiArguments } from './RANGE_MULTIAGGR';\n\nexport default {\n  IS_READ_ONLY: RANGE_MULTIAGGR.IS_READ_ONLY,\n  parseCommand(...args: Parameters<typeof transformRangeMultiArguments>) {\n    const parser = args[0];\n\n    parser.push('TS.REVRANGE');\n    transformRangeMultiArguments(...args);\n  },\n  transformReply: RANGE_MULTIAGGR.transformReply\n} as const satisfies Command;\n"]}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/helpers.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+import { CommandParser } from "@redis/client/dist/lib/client/parser";
+import { TsIgnoreOptions } from "./ADD";
+import { ArrayReply, BlobStringReply, DoubleReply, MapReply, NullReply, NumberReply, ReplyUnion, RespType, TuplesReply, TypeMapping, UnwrapReply } from "@redis/client/dist/lib/RESP/types";
+import { RedisVariadicArgument } from "@redis/client/dist/lib/commands/generic-transformers";
+export declare function parseIgnoreArgument(parser: CommandParser, ignore?: TsIgnoreOptions): void;
+export declare function parseRetentionArgument(parser: CommandParser, retention?: number): void;
+export declare const TIME_SERIES_ENCODING: {
+    readonly COMPRESSED: "COMPRESSED";
+    readonly UNCOMPRESSED: "UNCOMPRESSED";
+};
+export type TimeSeriesEncoding = typeof TIME_SERIES_ENCODING[keyof typeof TIME_SERIES_ENCODING];
+export declare function parseEncodingArgument(parser: CommandParser, encoding?: TimeSeriesEncoding): void;
+export declare function parseChunkSizeArgument(parser: CommandParser, chunkSize?: number): void;
+export declare const TIME_SERIES_DUPLICATE_POLICIES: {
+    readonly BLOCK: "BLOCK";
+    readonly FIRST: "FIRST";
+    readonly LAST: "LAST";
+    readonly MIN: "MIN";
+    readonly MAX: "MAX";
+    readonly SUM: "SUM";
+};
+export type TimeSeriesDuplicatePolicies = typeof TIME_SERIES_DUPLICATE_POLICIES[keyof typeof TIME_SERIES_DUPLICATE_POLICIES];
+export declare function parseDuplicatePolicy(parser: CommandParser, duplicatePolicy?: TimeSeriesDuplicatePolicies): void;
+export type Timestamp = number | Date | string;
+export declare function transformTimestampArgument(timestamp: Timestamp): string;
+export type Labels = {
+    [label: string]: string;
+};
+export declare function parseLabelsArgument(parser: CommandParser, labels?: Labels): void;
+export type SampleRawReply = TuplesReply<[timestamp: NumberReply, value: DoubleReply]>;
+export declare const transformSampleReply: {
+    2(reply: RespType<42, [NumberReply<number>, BlobStringReply<string>], never, [NumberReply<number>, BlobStringReply<string>]>): {
+        timestamp: NumberReply<number>;
+        value: number;
+    };
+    3(reply: SampleRawReply): {
+        timestamp: NumberReply<number>;
+        value: DoubleReply<number>;
+    };
+};
+export type SamplesRawReply = ArrayReply<SampleRawReply>;
+export declare const transformSamplesReply: {
+    2(reply: RespType<42, RespType<42, [NumberReply<number>, BlobStringReply<string>], never, [NumberReply<number>, BlobStringReply<string>]>[], never, RespType<42, [NumberReply<number>, BlobStringReply<string>], never, [NumberReply<number>, BlobStringReply<string>]>[]>): {
+        timestamp: NumberReply<number>;
+        value: number;
+    }[];
+    3(reply: SamplesRawReply): {
+        timestamp: NumberReply<number>;
+        value: DoubleReply<number>;
+    }[];
+};
+export type MultiAggregationSampleRawReply = TuplesReply<[
+    timestamp: NumberReply,
+    ...values: Array<DoubleReply>
+]>;
+export declare const transformMultiAggregationSampleReply: {
+    2(reply: RespType<42, [NumberReply<number>, ...BlobStringReply<string>[]], never, [NumberReply<number>, ...BlobStringReply<string>[]]>): {
+        timestamp: NumberReply<number>;
+        values: number[];
+    };
+    3(reply: MultiAggregationSampleRawReply): {
+        timestamp: NumberReply<number>;
+        values: DoubleReply<number>[];
+    };
+};
+export type MultiAggregationSamplesRawReply = ArrayReply<MultiAggregationSampleRawReply>;
+export declare const transformMultiAggregationSamplesReply: {
+    2(reply: RespType<42, RespType<42, [NumberReply<number>, ...BlobStringReply<string>[]], never, [NumberReply<number>, ...BlobStringReply<string>[]]>[], never, RespType<42, [NumberReply<number>, ...BlobStringReply<string>[]], never, [NumberReply<number>, ...BlobStringReply<string>[]]>[]>): {
+        timestamp: NumberReply<number>;
+        values: number[];
+    }[];
+    3(reply: MultiAggregationSamplesRawReply): {
+        timestamp: NumberReply<number>;
+        values: DoubleReply<number>[];
+    }[];
+};
+export declare function resp2MapToValue<RAW_VALUE extends TuplesReply<[key: BlobStringReply, ...rest: Array<ReplyUnion>]>, TRANSFORMED>(wrappedReply: ArrayReply<RAW_VALUE>, parseFunc: (rawValue: UnwrapReply<RAW_VALUE>) => TRANSFORMED, typeMapping?: TypeMapping): MapReply<BlobStringReply, TRANSFORMED>;
+export declare function resp3MapToValue<RAW_VALUE extends RespType<any, any, any, any>, // TODO: simplify types
+TRANSFORMED>(wrappedReply: MapReply<BlobStringReply, RAW_VALUE>, parseFunc: (rawValue: UnwrapReply<RAW_VALUE>) => TRANSFORMED): MapReply<BlobStringReply, TRANSFORMED>;
+export declare function parseSelectedLabelsArguments(parser: CommandParser, selectedLabels: RedisVariadicArgument): void;
+export type RawLabelValue = BlobStringReply | NullReply;
+export type RawLabels<T extends RawLabelValue> = ArrayReply<TuplesReply<[
+    label: BlobStringReply,
+    value: T
+]>>;
+export declare function transformRESP2Labels<T extends RawLabelValue>(labels: RawLabels<T>, typeMapping?: TypeMapping): MapReply<BlobStringReply, T>;
+export declare function transformRESP2LabelsWithSources<T extends RawLabelValue>(labels: RawLabels<T>, typeMapping?: TypeMapping): {
+    labels: MapReply<BlobStringReply<string>, T>;
+    sources: string[] | Buffer[];
+};
+//# sourceMappingURL=helpers.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../lib/commands/helpers.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAc,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAExM,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAE7F,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,eAAe,QAIlF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,QAI/E;AAED,eAAO,MAAM,oBAAoB;;;CAGvB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,OAAO,oBAAoB,CAAC,MAAM,OAAO,oBAAoB,CAAC,CAAC;AAEhG,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,kBAAkB,QAIzF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,QAI/E;AAED,eAAO,MAAM,8BAA8B;;;;;;;CAOjC,CAAC;AAEX,MAAM,MAAM,2BAA2B,GAAG,OAAO,8BAA8B,CAAC,MAAM,OAAO,8BAA8B,CAAC,CAAC;AAE7H,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,2BAA2B,QAIxG;AAED,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;AAE/C,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAQvE;AAED,MAAM,MAAM,MAAM,GAAG;IACnB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,QAQzE;AAED,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;AAEvF,eAAO,MAAM,oBAAoB;;;;;;;;;CAehC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;AAEzD,eAAO,MAAM,qBAAqB;;;;;;;;;CASjC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,WAAW,CAAC;IACvD,SAAS,EAAE,WAAW;IACtB,GAAG,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC;CAC9B,CAAC,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;CAehD,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CAAC,8BAA8B,CAAC,CAAC;AAEzF,eAAO,MAAM,qCAAqC;;;;;;;;;CASjD,CAAC;AAGF,wBAAgB,eAAe,CAC7B,SAAS,SAAS,WAAW,CAAC,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EACjF,WAAW,EAEX,YAAY,EAAE,UAAU,CAAC,SAAS,CAAC,EACnC,SAAS,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,SAAS,CAAC,KAAK,WAAW,EAC5D,WAAW,CAAC,EAAE,WAAW,GACxB,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,CA6BxC;AAED,wBAAgB,eAAe,CAE7B,SAAS,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,uBAAuB;AACvE,WAAW,EAEX,YAAY,EAAE,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC,EAClD,SAAS,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,SAAS,CAAC,KAAK,WAAW,GAC3D,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,CAmBxC;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,qBAAqB,QAItC;AAED,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,SAAS,CAAC;AAExD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,aAAa,IAAI,UAAU,CAAC,WAAW,CAAC;IACtE,KAAK,EAAE,eAAe;IACtB,KAAK,EAAE,CAAC;CACT,CAAC,CAAC,CAAC;AAEJ,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,aAAa,EAC1D,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,WAAW,CAAC,EAAE,WAAW,GACxB,QAAQ,CAAC,eAAe,EAAE,CAAC,CAAC,CA2B9B;AAED,wBAAgB,+BAA+B,CAAC,CAAC,SAAS,aAAa,EACrE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,WAAW,CAAC,EAAE,WAAW;;;EA2C1B"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/helpers.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRESP2LabelsWithSources = exports.transformRESP2Labels = exports.parseSelectedLabelsArguments = exports.resp3MapToValue = exports.resp2MapToValue = exports.transformMultiAggregationSamplesReply = exports.transformMultiAggregationSampleReply = exports.transformSamplesReply = exports.transformSampleReply = exports.parseLabelsArgument = exports.transformTimestampArgument = exports.parseDuplicatePolicy = exports.TIME_SERIES_DUPLICATE_POLICIES = exports.parseChunkSizeArgument = exports.parseEncodingArgument = exports.TIME_SERIES_ENCODING = exports.parseRetentionArgument = exports.parseIgnoreArgument = void 0;
+const client_1 = require("@redis/client");
+function parseIgnoreArgument(parser, ignore) {
+    if (ignore !== undefined) {
+        parser.push('IGNORE', ignore.maxTimeDiff.toString(), ignore.maxValDiff.toString());
+    }
+}
+exports.parseIgnoreArgument = parseIgnoreArgument;
+function parseRetentionArgument(parser, retention) {
+    if (retention !== undefined) {
+        parser.push('RETENTION', retention.toString());
+    }
+}
+exports.parseRetentionArgument = parseRetentionArgument;
+exports.TIME_SERIES_ENCODING = {
+    COMPRESSED: 'COMPRESSED',
+    UNCOMPRESSED: 'UNCOMPRESSED'
+};
+function parseEncodingArgument(parser, encoding) {
+    if (encoding !== undefined) {
+        parser.push('ENCODING', encoding);
+    }
+}
+exports.parseEncodingArgument = parseEncodingArgument;
+function parseChunkSizeArgument(parser, chunkSize) {
+    if (chunkSize !== undefined) {
+        parser.push('CHUNK_SIZE', chunkSize.toString());
+    }
+}
+exports.parseChunkSizeArgument = parseChunkSizeArgument;
+exports.TIME_SERIES_DUPLICATE_POLICIES = {
+    BLOCK: 'BLOCK',
+    FIRST: 'FIRST',
+    LAST: 'LAST',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    SUM: 'SUM'
+};
+function parseDuplicatePolicy(parser, duplicatePolicy) {
+    if (duplicatePolicy !== undefined) {
+        parser.push('DUPLICATE_POLICY', duplicatePolicy);
+    }
+}
+exports.parseDuplicatePolicy = parseDuplicatePolicy;
+function transformTimestampArgument(timestamp) {
+    if (typeof timestamp === 'string')
+        return timestamp;
+    return (typeof timestamp === 'number' ?
+        timestamp :
+        timestamp.getTime()).toString();
+}
+exports.transformTimestampArgument = transformTimestampArgument;
+function parseLabelsArgument(parser, labels) {
+    if (labels) {
+        parser.push('LABELS');
+        for (const [label, value] of Object.entries(labels)) {
+            parser.push(label, value);
+        }
+    }
+}
+exports.parseLabelsArgument = parseLabelsArgument;
+exports.transformSampleReply = {
+    2(reply) {
+        const [timestamp, value] = reply;
+        return {
+            timestamp,
+            value: Number(value) // TODO: use double type mapping instead
+        };
+    },
+    3(reply) {
+        const [timestamp, value] = reply;
+        return {
+            timestamp,
+            value
+        };
+    }
+};
+exports.transformSamplesReply = {
+    2(reply) {
+        return reply
+            .map(sample => exports.transformSampleReply[2](sample));
+    },
+    3(reply) {
+        return reply
+            .map(sample => exports.transformSampleReply[3](sample));
+    }
+};
+exports.transformMultiAggregationSampleReply = {
+    2(reply) {
+        const [timestamp, ...values] = reply;
+        return {
+            timestamp,
+            values: values.map(value => Number(value))
+        };
+    },
+    3(reply) {
+        const [timestamp, ...values] = reply;
+        return {
+            timestamp,
+            values
+        };
+    }
+};
+exports.transformMultiAggregationSamplesReply = {
+    2(reply) {
+        return reply
+            .map(sample => exports.transformMultiAggregationSampleReply[2](sample));
+    },
+    3(reply) {
+        return reply
+            .map(sample => exports.transformMultiAggregationSampleReply[3](sample));
+    }
+};
+// TODO: move to @redis/client?
+function resp2MapToValue(wrappedReply, parseFunc, typeMapping) {
+    const reply = wrappedReply;
+    switch (typeMapping?.[client_1.RESP_TYPES.MAP]) {
+        case Map: {
+            const ret = new Map();
+            for (const wrappedTuple of reply) {
+                const tuple = wrappedTuple;
+                const key = tuple[0];
+                ret.set(key.toString(), parseFunc(tuple));
+            }
+            return ret;
+        }
+        case Array: {
+            for (const wrappedTuple of reply) {
+                const tuple = wrappedTuple;
+                tuple[1] = parseFunc(tuple);
+            }
+            return reply;
+        }
+        default: {
+            const ret = {};
+            for (const wrappedTuple of reply) {
+                const tuple = wrappedTuple;
+                const key = tuple[0];
+                ret[key.toString()] = parseFunc(tuple);
+            }
+            return ret;
+        }
+    }
+}
+exports.resp2MapToValue = resp2MapToValue;
+function resp3MapToValue(wrappedReply, parseFunc) {
+    const reply = wrappedReply;
+    if (reply instanceof Array) {
+        for (let i = 1; i < reply.length; i += 2) {
+            reply[i] = parseFunc(reply[i]);
+        }
+    }
+    else if (reply instanceof Map) {
+        for (const [key, value] of reply.entries()) {
+            reply.set(key, parseFunc(value));
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(reply)) {
+            reply[key] = parseFunc(value);
+        }
+    }
+    return reply;
+}
+exports.resp3MapToValue = resp3MapToValue;
+function parseSelectedLabelsArguments(parser, selectedLabels) {
+    parser.push('SELECTED_LABELS');
+    parser.pushVariadic(selectedLabels);
+}
+exports.parseSelectedLabelsArguments = parseSelectedLabelsArguments;
+function transformRESP2Labels(labels, typeMapping) {
+    const unwrappedLabels = labels;
+    switch (typeMapping?.[client_1.RESP_TYPES.MAP]) {
+        case Map: {
+            const map = new Map();
+            for (const tuple of unwrappedLabels) {
+                const [key, value] = tuple;
+                const unwrappedKey = key;
+                map.set(unwrappedKey.toString(), value);
+            }
+            return map;
+        }
+        case Array:
+            return unwrappedLabels.flat();
+        case Object:
+        default: {
+            const labelsObject = {};
+            for (const tuple of unwrappedLabels) {
+                const [key, value] = tuple;
+                const unwrappedKey = key;
+                labelsObject[unwrappedKey.toString()] = value;
+            }
+            return labelsObject;
+        }
+    }
+}
+exports.transformRESP2Labels = transformRESP2Labels;
+function transformRESP2LabelsWithSources(labels, typeMapping) {
+    const unwrappedLabels = labels;
+    const to = unwrappedLabels.length - 2; // ignore __reducer__ and __source__
+    let transformedLabels;
+    switch (typeMapping?.[client_1.RESP_TYPES.MAP]) {
+        case Map: {
+            const map = new Map();
+            for (let i = 0; i < to; i++) {
+                const [key, value] = unwrappedLabels[i];
+                const unwrappedKey = key;
+                map.set(unwrappedKey.toString(), value);
+            }
+            transformedLabels = map;
+            break;
+        }
+        case Array:
+            transformedLabels = unwrappedLabels.slice(0, to).flat();
+            break;
+        case Object:
+        default: {
+            const labelsObject = {};
+            for (let i = 0; i < to; i++) {
+                const [key, value] = unwrappedLabels[i];
+                const unwrappedKey = key;
+                labelsObject[unwrappedKey.toString()] = value;
+            }
+            transformedLabels = labelsObject;
+            break;
+        }
+    }
+    const sourcesTuple = unwrappedLabels[unwrappedLabels.length - 1];
+    const unwrappedSourcesTuple = sourcesTuple;
+    // the __source__ label will never be null
+    const transformedSources = transformRESP2Sources(unwrappedSourcesTuple[1]);
+    return {
+        labels: transformedLabels,
+        sources: transformedSources
+    };
+}
+exports.transformRESP2LabelsWithSources = transformRESP2LabelsWithSources;
+function transformRESP2Sources(sourcesRaw) {
+    // if a label contains "," this function will produce incorrcet results..
+    // there is not much we can do about it, and we assume most users won't be using "," in their labels..
+    const unwrappedSources = sourcesRaw;
+    if (typeof unwrappedSources === 'string') {
+        return unwrappedSources.split(',');
+    }
+    const indexOfComma = unwrappedSources.indexOf(',');
+    if (indexOfComma === -1) {
+        return [unwrappedSources];
+    }
+    const sourcesArray = [
+        unwrappedSources.subarray(0, indexOfComma)
+    ];
+    let previousComma = indexOfComma + 1;
+    while (true) {
+        const indexOf = unwrappedSources.indexOf(',', previousComma);
+        if (indexOf === -1) {
+            sourcesArray.push(unwrappedSources.subarray(previousComma));
+            break;
+        }
+        const source = unwrappedSources.subarray(previousComma, indexOf);
+        sourcesArray.push(source);
+        previousComma = indexOf + 1;
+    }
+    return sourcesArray;
+}
+//# sourceMappingURL=helpers.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/index.d.ts

@@ -0,0 +1,1648 @@
+/// <reference types="node" />
+export * from './helpers';
+declare const _default: {
+    /**
+     * Creates or appends a sample to a time series
+     * @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
+     */
+    readonly ADD: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, timestamp: import("./helpers").Timestamp, value: number, options?: import("./ADD").TsAddOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Creates or appends a sample to a time series
+     * @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
+     */
+    readonly add: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, timestamp: import("./helpers").Timestamp, value: number, options?: import("./ADD").TsAddOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Alters the configuration of an existing time series
+     * @param key - The key name for the time series
+     * @param options - Configuration parameters to alter
+     */
+    readonly ALTER: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./ALTER").TsAlterOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Alters the configuration of an existing time series
+     * @param key - The key name for the time series
+     * @param options - Configuration parameters to alter
+     */
+    readonly alter: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./ALTER").TsAlterOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Creates a new time series
+     * @param key - The key name for the new time series
+     * @param options - Optional configuration parameters
+     */
+    readonly CREATE: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./CREATE").TsCreateOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Creates a new time series
+     * @param key - The key name for the new time series
+     * @param options - Optional configuration parameters
+     */
+    readonly create: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./CREATE").TsCreateOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Creates a compaction rule from source time series to destination time series
+     * @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
+     */
+    readonly CREATERULE: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, sourceKey: import("@redis/client/dist/lib/RESP/types").RedisArgument, destinationKey: import("@redis/client/dist/lib/RESP/types").RedisArgument, aggregationType: import("./CREATERULE").TimeSeriesAggregationType, bucketDuration: number, alignTimestamp?: number | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Creates a compaction rule from source time series to destination time series
+     * @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
+     */
+    readonly createRule: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, sourceKey: import("@redis/client/dist/lib/RESP/types").RedisArgument, destinationKey: import("@redis/client/dist/lib/RESP/types").RedisArgument, aggregationType: import("./CREATERULE").TimeSeriesAggregationType, bucketDuration: number, alignTimestamp?: number | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Decreases the value of a time series by a given amount
+     * @param args - Arguments passed to the parseIncrByArguments function
+     */
+    readonly DECRBY: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, value: number, options?: import("./INCRBY").TsIncrByOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Decreases the value of a time series by a given amount
+     * @param args - Arguments passed to the parseIncrByArguments function
+     */
+    readonly decrBy: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, value: number, options?: import("./INCRBY").TsIncrByOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Deletes samples between two timestamps from a time series
+     * @param key - The key name of the time series
+     * @param fromTimestamp - Start timestamp to delete from
+     * @param toTimestamp - End timestamp to delete until
+     */
+    readonly DEL: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Deletes samples between two timestamps from a time series
+     * @param key - The key name of the time series
+     * @param fromTimestamp - Start timestamp to delete from
+     * @param toTimestamp - End timestamp to delete until
+     */
+    readonly del: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Deletes a compaction rule between source and destination time series
+     * @param sourceKey - The source time series key
+     * @param destinationKey - The destination time series key
+     */
+    readonly DELETERULE: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, sourceKey: import("@redis/client/dist/lib/RESP/types").RedisArgument, destinationKey: import("@redis/client/dist/lib/RESP/types").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Deletes a compaction rule between source and destination time series
+     * @param sourceKey - The source time series key
+     * @param destinationKey - The destination time series key
+     */
+    readonly deleteRule: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, sourceKey: import("@redis/client/dist/lib/RESP/types").RedisArgument, destinationKey: import("@redis/client/dist/lib/RESP/types").RedisArgument) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").SimpleStringReply<"OK">;
+    };
+    /**
+     * Gets the last sample of a time series
+     * @param key - The key name of the time series
+     * @param options - Optional parameters for the command
+     */
+    readonly GET: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./GET").TsGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").Resp2Reply<import("./GET").TsGetReply>>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            } | null;
+            readonly 3: (this: void, reply: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("./GET").TsGetReply>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            } | null;
+        };
+    };
+    /**
+     * Gets the last sample of a time series
+     * @param key - The key name of the time series
+     * @param options - Optional parameters for the command
+     */
+    readonly get: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, options?: import("./GET").TsGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("@redis/client/dist/lib/RESP/types").Resp2Reply<import("./GET").TsGetReply>>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            } | null;
+            readonly 3: (this: void, reply: import("@redis/client/dist/lib/RESP/types").UnwrapReply<import("./GET").TsGetReply>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            } | null;
+        };
+    };
+    /**
+     * Increases the value of a time series by a given amount
+     * @param args - Arguments passed to the {@link parseIncrByArguments} function
+     */
+    readonly INCRBY: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, value: number, options?: import("./INCRBY").TsIncrByOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Increases the value of a time series by a given amount
+     * @param args - Arguments passed to the {@link parseIncrByArguments} function
+     */
+    readonly incrBy: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, value: number, options?: import("./INCRBY").TsIncrByOptions | undefined) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+    };
+    /**
+     * Gets debug information about a time series
+     * @param key - The key name of the time series
+     */
+    readonly INFO_DEBUG: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: string) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: [...import("./INFO").InfoRawReplyTypes[], "keySelfName", import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, "Chunks", ["startTimestamp", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "endTimestamp", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "samples", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "size", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "bytesPerSample", import("@redis/client/dist/lib/RESP/types").SimpleStringReply<string>][]], _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO_DEBUG").InfoDebugReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO_DEBUG").InfoDebugReply;
+        };
+    };
+    /**
+     * Gets debug information about a time series
+     * @param key - The key name of the time series
+     */
+    readonly infoDebug: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: string) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: [...import("./INFO").InfoRawReplyTypes[], "keySelfName", import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, "Chunks", ["startTimestamp", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "endTimestamp", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "samples", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "size", import("@redis/client/dist/lib/RESP/types").NumberReply<number>, "bytesPerSample", import("@redis/client/dist/lib/RESP/types").SimpleStringReply<string>][]], _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO_DEBUG").InfoDebugReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO_DEBUG").InfoDebugReply;
+        };
+    };
+    /**
+     * Gets information about a time series
+     * @param key - The key name of the time series
+     */
+    readonly INFO: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: string) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("./INFO").InfoRawReply, _: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO").InfoReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO").InfoReply;
+        };
+    };
+    /**
+     * Gets information about a time series
+     * @param key - The key name of the time series
+     */
+    readonly info: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: string) => void;
+        readonly transformReply: {
+            readonly 2: (reply: import("./INFO").InfoRawReply, _: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO").InfoReply;
+            readonly 3: (reply: import("@redis/client/dist/lib/RESP/types").ReplyUnion, preserve?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("./INFO").InfoReply;
+        };
+    };
+    /**
+     * Adds multiple samples to multiple time series
+     * @param toAdd - Array of samples to add to different time series
+     */
+    readonly MADD: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, toAdd: import("./MADD").TsMAddSample[]) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").SimpleErrorReply | import("@redis/client/dist/lib/RESP/types").NumberReply<number>>;
+    };
+    /**
+     * Adds multiple samples to multiple time series
+     * @param toAdd - Array of samples to add to different time series
+     */
+    readonly mAdd: {
+        readonly IS_READ_ONLY: false;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, toAdd: import("./MADD").TsMAddSample[]) => void;
+        readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").SimpleErrorReply | import("@redis/client/dist/lib/RESP/types").NumberReply<number>>;
+    };
+    /**
+     * Gets the last samples matching a specific filter with selected labels
+     * @param filter - Filter to match time series keys
+     * @param selectedLabels - Labels to include in the output
+     * @param options - Optional parameters for the command
+     */
+    readonly MGET_SELECTED_LABELS: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./MGET").TsMGetOptions | undefined) => void;
+        readonly transformReply: {
+            2(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply2<import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                };
+            }>;
+            3(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply3<import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                };
+            }>;
+        };
+    };
+    /**
+     * Gets the last samples matching a specific filter with selected labels
+     * @param filter - Filter to match time series keys
+     * @param selectedLabels - Labels to include in the output
+     * @param options - Optional parameters for the command
+     */
+    readonly mGetSelectedLabels: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./MGET").TsMGetOptions | undefined) => void;
+        readonly transformReply: {
+            2(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply2<import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                };
+            }>;
+            3(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply3<import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                };
+            }>;
+        };
+    };
+    /**
+     * Gets the last samples matching a specific filter with labels
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MGET_WITHLABELS: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./MGET_WITHLABELS").TsMGetWithLabelsOptions | undefined) => void;
+        readonly transformReply: {
+            2(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply2<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                };
+            }>;
+            3(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply3<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                };
+            }>;
+        };
+    };
+    /**
+     * Gets the last samples matching a specific filter with labels
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mGetWithLabels: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./MGET_WITHLABELS").TsMGetWithLabelsOptions | undefined) => void;
+        readonly transformReply: {
+            2(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply2<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                };
+            }>;
+            3(this: void, reply: import("./MGET_WITHLABELS").MGetLabelsRawReply3<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>): import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                };
+            }>;
+        };
+    };
+    /**
+     * Gets the last samples matching a specific filter from multiple time series
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MGET: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./MGET").TsMGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MGET").MGetRawReply2, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                };
+            }>;
+            readonly 3: (this: void, reply: import("./MGET").MGetRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                };
+            }>;
+        };
+    };
+    /**
+     * Gets the last samples matching a specific filter from multiple time series
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mGet: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./MGET").TsMGetOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MGET").MGetRawReply2, _: any, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                };
+            }>;
+            readonly 3: (this: void, reply: import("./MGET").MGetRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                sample: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                };
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_GROUPBY: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void; /**
+         * Creates a compaction rule from source time series to destination time series
+         * @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
+         */
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeGroupBy: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void; /**
+         * Creates a compaction rule from source time series to destination time series
+         * @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
+         */
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_MULTIAGGR: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[]>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeMultiAggr: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[]>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_SELECTED_LABELS_MULTIAGGR: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeSelectedLabelsMultiAggr: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_SELECTED_LABELS_GROUPBY: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        }; /**
+         * Creates or appends a sample to a time series
+         * @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
+         */
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeSelectedLabelsGroupBy: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        }; /**
+         * Creates or appends a sample to a time series
+         * @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
+         */
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_SELECTED_LABELS: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeSelectedLabels: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_WITHLABELS_MULTIAGGR: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Creates a new time series
+                 * @param key - The key name for the new time series
+                 * @param options - Optional configuration parameters
+                 */
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeWithLabelsMultiAggr: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Creates a new time series
+                 * @param key - The key name for the new time series
+                 * @param options - Optional configuration parameters
+                 */
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_WITHLABELS_GROUPBY: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sources: string[] | Buffer[];
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+                sources: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeWithLabelsGroupBy: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sources: string[] | Buffer[];
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+                sources: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE_WITHLABELS: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[]; /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRangeWithLabels: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[]; /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MRANGE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE").TsMRangeRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE").TsMRangeRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[]>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRange: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE").TsMRangeRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE").TsMRangeRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[]>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_GROUPBY: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeGroupBy: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_GROUPBY").TsMRangeGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_MULTIAGGR: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[]>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeMultiAggr: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE_MULTIAGGR").TsMRangeMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[]>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_SELECTED_LABELS_MULTIAGGR: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeSelectedLabelsMultiAggr: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_MULTIAGGR").TsMRangeSelectedLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_SELECTED_LABELS_GROUPBY: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeSelectedLabelsGroupBy: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_SELECTED_LABELS: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeSelectedLabels: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, selectedLabels: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_SELECTED_LABELS").TsMRangeSelectedLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").NullReply | import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_WITHLABELS_MULTIAGGR: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Creates a new time series
+                 * @param key - The key name for the new time series
+                 * @param options - Optional configuration parameters
+                 */
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeWithLabelsMultiAggr: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: number[];
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_MULTIAGGR").TsMRangeWithLabelsMultiRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Creates a new time series
+                 * @param key - The key name for the new time series
+                 * @param options - Optional configuration parameters
+                 */
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_WITHLABELS_GROUPBY: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sources: string[] | Buffer[];
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+                sources: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeWithLabelsGroupBy: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, groupBy: import("./MRANGE_GROUPBY").TsMRangeGroupBy, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                sources: string[] | Buffer[];
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[];
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS_GROUPBY").TsMRangeWithLabelsGroupByRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+                sources: import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE_WITHLABELS: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[]; /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRangeWithLabels: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: Record<string, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: number;
+                }[]; /**
+                 * Alters the configuration of an existing time series
+                 * @param key - The key name for the time series
+                 * @param options - Configuration parameters to alter
+                 */
+            }>;
+            readonly 3: (this: void, reply: import("./MRANGE_WITHLABELS").TsMRangeWithLabelsRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                labels: import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+                samples: {
+                    timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                    value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+                }[];
+            }>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly MREVRANGE: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE").TsMRangeRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE").TsMRangeRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[]>;
+        };
+    };
+    /**
+     * Gets samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    readonly mRevRange: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (parser: import("@redis/client").CommandParser, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("./MRANGE").TsMRangeRawReply2, _?: unknown, typeMapping?: import("@redis/client/dist/lib/RESP/types").TypeMapping | undefined) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[]>;
+            readonly 3: (this: void, reply: import("./MRANGE").TsMRangeRawReply3) => import("@redis/client/dist/lib/RESP/types").MapReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>, {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[]>;
+        };
+    };
+    /**
+     * Queries the index for time series matching a specific filter
+     * @param filter - Filter to match time series labels
+     */
+    readonly QUERYINDEX: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Queries the index for time series matching a specific filter
+     * @param filter - Filter to match time series labels
+     */
+    readonly queryIndex: {
+        readonly NOT_KEYED_COMMAND: true;
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, filter: import("@redis/client/dist/lib/commands/generic-transformers").RedisVariadicArgument) => void;
+        readonly transformReply: {
+            readonly 2: () => import("@redis/client/dist/lib/RESP/types").ArrayReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+            readonly 3: () => import("@redis/client/dist/lib/RESP/types").SetReply<import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>>;
+        };
+    };
+    /**
+     * Gets multi-aggregation samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    readonly RANGE_MULTIAGGR: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").MultiAggregationSamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        };
+    };
+    /**
+     * Gets multi-aggregation samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    readonly rangeMultiAggr: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").MultiAggregationSamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        };
+    };
+    /**
+     * Gets samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    readonly RANGE: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").SamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        };
+    };
+    /**
+     * Gets samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    readonly range: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").SamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        };
+    };
+    /**
+     * Gets multi-aggregation samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    readonly REVRANGE_MULTIAGGR: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").MultiAggregationSamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        };
+    };
+    /**
+     * Gets multi-aggregation samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    readonly revRangeMultiAggr: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options: import("./RANGE_MULTIAGGR").TsRangeMultiAggrOptions) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, ...import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>[]]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: number[];
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").MultiAggregationSamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                values: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>[];
+            }[];
+        };
+    };
+    /**
+     * Gets samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    readonly REVRANGE: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").SamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        };
+    };
+    /**
+     * Gets samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    readonly revRange: {
+        readonly IS_READ_ONLY: true;
+        readonly parseCommand: (this: void, parser: import("@redis/client").CommandParser, key: import("@redis/client/dist/lib/RESP/types").RedisArgument, fromTimestamp: import("./helpers").Timestamp, toTimestamp: import("./helpers").Timestamp, options?: import("./RANGE").TsRangeOptions | undefined) => void;
+        readonly transformReply: {
+            readonly 2: (this: void, reply: import("@redis/client/dist/lib/RESP/types").RespType<42, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[], never, import("@redis/client/dist/lib/RESP/types").RespType<42, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>], never, [import("@redis/client/dist/lib/RESP/types").NumberReply<number>, import("@redis/client/dist/lib/RESP/types").BlobStringReply<string>]>[]>) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: number;
+            }[];
+            readonly 3: (this: void, reply: import("./helpers").SamplesRawReply) => {
+                timestamp: import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+                value: import("@redis/client/dist/lib/RESP/types").DoubleReply<number>;
+            }[];
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/commands/index.ts"],"names":[],"mappings":";AAwCA,cAAc,WAAW,CAAC;;IAGxB;;;;;;OAMG;;;;;;IAEH;;;;;;OAMG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;;;;OAOG;;;;;;IAEH;;;;;;;OAOG;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;;;OAKG;;;;;;IAEH;;;;;OAKG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;OAIG;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;OAGG;;;;;;;;;IAEH;;;OAGG;;;;;;;;;IAEH;;;OAGG;;;;;;;;;IAEH;;;OAGG;;;;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;OAGG;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;6XAvJH;;;;;;;WAOG;;;;;;;;;;;;;;;;IAkJH;;;;;;;OAOG;;;6XAhKH;;;;;;;WAOG;;;;;;;;;;;;;;;;IA2JH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;WA5OH;;;;;;WAMG;;IAwOH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;WAtPH;;;;;;WAMG;;IAkPH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;gBA5PH;;;;mBAIG;;;;;;;;IA0PH;;;;;;OAMG;;;;;;;;;;;;;;;gBApQH;;;;mBAIG;;;;;;;;IAkQH;;;;;;;OAOG;;;;;;;;;;;;;;;gBAzRH;;;;mBAIG;;;;;;;;;IAuRH;;;;;;;OAOG;;;;;;;;;;;;;;;gBAlSH;;;;mBAIG;;;;;;;;;IAgSH;;;;;;OAMG;;;;;;;;;;;qBA1SH;;;;mBAIG;;;;;;;;;;;IAwSH;;;;;;OAMG;;;;;;;;;;;qBAlTH;;;;mBAIG;;;;;;;;;;;IAgTH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;;OAQG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;;OAOG;;;;;;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;gBAxZH;;;;mBAIG;;;;;;;;IAsZH;;;;;;OAMG;;;;;;;;;;;;;;;gBAhaH;;;;mBAIG;;;;;;;;IA8ZH;;;;;;;OAOG;;;;;;;;;;;;;;;gBArbH;;;;mBAIG;;;;;;;;;IAmbH;;;;;;;OAOG;;;;;;;;;;;;;;;gBA9bH;;;;mBAIG;;;;;;;;;IA4bH;;;;;;OAMG;;;;;;;;;;;qBAtcH;;;;mBAIG;;;;;;;;;;;IAocH;;;;;;OAMG;;;;;;;;;;;qBA9cH;;;;mBAIG;;;;;;;;;;;IA4cH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;;;;OAMG;;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;IAEH;;;OAGG;;;;;;;;;;;;;;;;AAjiBL,wBAmiBmC"}

landvex-report-system/node_modules/@redis/time-series/dist/lib/commands/index.js

@@ -0,0 +1,607 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ADD_1 = __importDefault(require("./ADD"));
+const ALTER_1 = __importDefault(require("./ALTER"));
+const CREATE_1 = __importDefault(require("./CREATE"));
+const CREATERULE_1 = __importDefault(require("./CREATERULE"));
+const DECRBY_1 = __importDefault(require("./DECRBY"));
+const DEL_1 = __importDefault(require("./DEL"));
+const DELETERULE_1 = __importDefault(require("./DELETERULE"));
+const GET_1 = __importDefault(require("./GET"));
+const INCRBY_1 = __importDefault(require("./INCRBY"));
+const INFO_DEBUG_1 = __importDefault(require("./INFO_DEBUG"));
+const INFO_1 = __importDefault(require("./INFO"));
+const MADD_1 = __importDefault(require("./MADD"));
+const MGET_SELECTED_LABELS_1 = __importDefault(require("./MGET_SELECTED_LABELS"));
+const MGET_WITHLABELS_1 = __importDefault(require("./MGET_WITHLABELS"));
+const MGET_1 = __importDefault(require("./MGET"));
+const MRANGE_GROUPBY_1 = __importDefault(require("./MRANGE_GROUPBY"));
+const MRANGE_MULTIAGGR_1 = __importDefault(require("./MRANGE_MULTIAGGR"));
+const MRANGE_SELECTED_LABELS_MULTIAGGR_1 = __importDefault(require("./MRANGE_SELECTED_LABELS_MULTIAGGR"));
+const MRANGE_SELECTED_LABELS_GROUPBY_1 = __importDefault(require("./MRANGE_SELECTED_LABELS_GROUPBY"));
+const MRANGE_SELECTED_LABELS_1 = __importDefault(require("./MRANGE_SELECTED_LABELS"));
+const MRANGE_WITHLABELS_MULTIAGGR_1 = __importDefault(require("./MRANGE_WITHLABELS_MULTIAGGR"));
+const MRANGE_WITHLABELS_GROUPBY_1 = __importDefault(require("./MRANGE_WITHLABELS_GROUPBY"));
+const MRANGE_WITHLABELS_1 = __importDefault(require("./MRANGE_WITHLABELS"));
+const MRANGE_1 = __importDefault(require("./MRANGE"));
+const MREVRANGE_GROUPBY_1 = __importDefault(require("./MREVRANGE_GROUPBY"));
+const MREVRANGE_MULTIAGGR_1 = __importDefault(require("./MREVRANGE_MULTIAGGR"));
+const MREVRANGE_SELECTED_LABELS_MULTIAGGR_1 = __importDefault(require("./MREVRANGE_SELECTED_LABELS_MULTIAGGR"));
+const MREVRANGE_SELECTED_LABELS_GROUPBY_1 = __importDefault(require("./MREVRANGE_SELECTED_LABELS_GROUPBY"));
+const MREVRANGE_SELECTED_LABELS_1 = __importDefault(require("./MREVRANGE_SELECTED_LABELS"));
+const MREVRANGE_WITHLABELS_MULTIAGGR_1 = __importDefault(require("./MREVRANGE_WITHLABELS_MULTIAGGR"));
+const MREVRANGE_WITHLABELS_GROUPBY_1 = __importDefault(require("./MREVRANGE_WITHLABELS_GROUPBY"));
+const MREVRANGE_WITHLABELS_1 = __importDefault(require("./MREVRANGE_WITHLABELS"));
+const MREVRANGE_1 = __importDefault(require("./MREVRANGE"));
+const QUERYINDEX_1 = __importDefault(require("./QUERYINDEX"));
+const RANGE_MULTIAGGR_1 = __importDefault(require("./RANGE_MULTIAGGR"));
+const RANGE_1 = __importDefault(require("./RANGE"));
+const REVRANGE_MULTIAGGR_1 = __importDefault(require("./REVRANGE_MULTIAGGR"));
+const REVRANGE_1 = __importDefault(require("./REVRANGE"));
+__exportStar(require("./helpers"), exports);
+exports.default = {
+    /**
+     * Creates or appends a sample to a time series
+     * @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
+     */
+    ADD: ADD_1.default,
+    /**
+     * Creates or appends a sample to a time series
+     * @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
+     */
+    add: ADD_1.default,
+    /**
+     * Alters the configuration of an existing time series
+     * @param key - The key name for the time series
+     * @param options - Configuration parameters to alter
+     */
+    ALTER: ALTER_1.default,
+    /**
+     * Alters the configuration of an existing time series
+     * @param key - The key name for the time series
+     * @param options - Configuration parameters to alter
+     */
+    alter: ALTER_1.default,
+    /**
+     * Creates a new time series
+     * @param key - The key name for the new time series
+     * @param options - Optional configuration parameters
+     */
+    CREATE: CREATE_1.default,
+    /**
+     * Creates a new time series
+     * @param key - The key name for the new time series
+     * @param options - Optional configuration parameters
+     */
+    create: CREATE_1.default,
+    /**
+     * Creates a compaction rule from source time series to destination time series
+     * @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
+     */
+    CREATERULE: CREATERULE_1.default,
+    /**
+     * Creates a compaction rule from source time series to destination time series
+     * @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
+     */
+    createRule: CREATERULE_1.default,
+    /**
+     * Decreases the value of a time series by a given amount
+     * @param args - Arguments passed to the parseIncrByArguments function
+     */
+    DECRBY: DECRBY_1.default,
+    /**
+     * Decreases the value of a time series by a given amount
+     * @param args - Arguments passed to the parseIncrByArguments function
+     */
+    decrBy: DECRBY_1.default,
+    /**
+     * Deletes samples between two timestamps from a time series
+     * @param key - The key name of the time series
+     * @param fromTimestamp - Start timestamp to delete from
+     * @param toTimestamp - End timestamp to delete until
+     */
+    DEL: DEL_1.default,
+    /**
+     * Deletes samples between two timestamps from a time series
+     * @param key - The key name of the time series
+     * @param fromTimestamp - Start timestamp to delete from
+     * @param toTimestamp - End timestamp to delete until
+     */
+    del: DEL_1.default,
+    /**
+     * Deletes a compaction rule between source and destination time series
+     * @param sourceKey - The source time series key
+     * @param destinationKey - The destination time series key
+     */
+    DELETERULE: DELETERULE_1.default,
+    /**
+     * Deletes a compaction rule between source and destination time series
+     * @param sourceKey - The source time series key
+     * @param destinationKey - The destination time series key
+     */
+    deleteRule: DELETERULE_1.default,
+    /**
+     * Gets the last sample of a time series
+     * @param key - The key name of the time series
+     * @param options - Optional parameters for the command
+     */
+    GET: GET_1.default,
+    /**
+     * Gets the last sample of a time series
+     * @param key - The key name of the time series
+     * @param options - Optional parameters for the command
+     */
+    get: GET_1.default,
+    /**
+     * Increases the value of a time series by a given amount
+     * @param args - Arguments passed to the {@link parseIncrByArguments} function
+     */
+    INCRBY: INCRBY_1.default,
+    /**
+     * Increases the value of a time series by a given amount
+     * @param args - Arguments passed to the {@link parseIncrByArguments} function
+     */
+    incrBy: INCRBY_1.default,
+    /**
+     * Gets debug information about a time series
+     * @param key - The key name of the time series
+     */
+    INFO_DEBUG: INFO_DEBUG_1.default,
+    /**
+     * Gets debug information about a time series
+     * @param key - The key name of the time series
+     */
+    infoDebug: INFO_DEBUG_1.default,
+    /**
+     * Gets information about a time series
+     * @param key - The key name of the time series
+     */
+    INFO: INFO_1.default,
+    /**
+     * Gets information about a time series
+     * @param key - The key name of the time series
+     */
+    info: INFO_1.default,
+    /**
+     * Adds multiple samples to multiple time series
+     * @param toAdd - Array of samples to add to different time series
+     */
+    MADD: MADD_1.default,
+    /**
+     * Adds multiple samples to multiple time series
+     * @param toAdd - Array of samples to add to different time series
+     */
+    mAdd: MADD_1.default,
+    /**
+     * Gets the last samples matching a specific filter with selected labels
+     * @param filter - Filter to match time series keys
+     * @param selectedLabels - Labels to include in the output
+     * @param options - Optional parameters for the command
+     */
+    MGET_SELECTED_LABELS: MGET_SELECTED_LABELS_1.default,
+    /**
+     * Gets the last samples matching a specific filter with selected labels
+     * @param filter - Filter to match time series keys
+     * @param selectedLabels - Labels to include in the output
+     * @param options - Optional parameters for the command
+     */
+    mGetSelectedLabels: MGET_SELECTED_LABELS_1.default,
+    /**
+     * Gets the last samples matching a specific filter with labels
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MGET_WITHLABELS: MGET_WITHLABELS_1.default,
+    /**
+     * Gets the last samples matching a specific filter with labels
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mGetWithLabels: MGET_WITHLABELS_1.default,
+    /**
+     * Gets the last samples matching a specific filter from multiple time series
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MGET: MGET_1.default,
+    /**
+     * Gets the last samples matching a specific filter from multiple time series
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mGet: MGET_1.default,
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_GROUPBY: MRANGE_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    mRangeGroupBy: MRANGE_GROUPBY_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_MULTIAGGR: MRANGE_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRangeMultiAggr: MRANGE_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_SELECTED_LABELS_MULTIAGGR: MRANGE_SELECTED_LABELS_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRangeSelectedLabelsMultiAggr: MRANGE_SELECTED_LABELS_MULTIAGGR_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_SELECTED_LABELS_GROUPBY: MRANGE_SELECTED_LABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    mRangeSelectedLabelsGroupBy: MRANGE_SELECTED_LABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_SELECTED_LABELS: MRANGE_SELECTED_LABELS_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRangeSelectedLabels: MRANGE_SELECTED_LABELS_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_WITHLABELS_MULTIAGGR: MRANGE_WITHLABELS_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRangeWithLabelsMultiAggr: MRANGE_WITHLABELS_MULTIAGGR_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_WITHLABELS_GROUPBY: MRANGE_WITHLABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels and grouping
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    mRangeWithLabelsGroupBy: MRANGE_WITHLABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MRANGE_WITHLABELS: MRANGE_WITHLABELS_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRangeWithLabels: MRANGE_WITHLABELS_1.default,
+    /**
+     * Gets samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MRANGE: MRANGE_1.default,
+    /**
+     * Gets samples for time series matching a specific filter within a time range
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRange: MRANGE_1.default,
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_GROUPBY: MREVRANGE_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter within a time range with grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeGroupBy: MREVRANGE_GROUPBY_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_MULTIAGGR: MREVRANGE_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeMultiAggr: MREVRANGE_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_SELECTED_LABELS_MULTIAGGR: MREVRANGE_SELECTED_LABELS_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeSelectedLabelsMultiAggr: MREVRANGE_SELECTED_LABELS_MULTIAGGR_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_SELECTED_LABELS_GROUPBY: MREVRANGE_SELECTED_LABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeSelectedLabelsGroupBy: MREVRANGE_SELECTED_LABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_SELECTED_LABELS: MREVRANGE_SELECTED_LABELS_1.default,
+    /**
+     * Gets samples for time series matching a filter with selected labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param selectedLabels - Labels to include in the output
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeSelectedLabels: MREVRANGE_SELECTED_LABELS_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_WITHLABELS_MULTIAGGR: MREVRANGE_WITHLABELS_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeWithLabelsMultiAggr: MREVRANGE_WITHLABELS_MULTIAGGR_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_WITHLABELS_GROUPBY: MREVRANGE_WITHLABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels and grouping (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param groupBy - Group by parameters
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeWithLabelsGroupBy: MREVRANGE_WITHLABELS_GROUPBY_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE_WITHLABELS: MREVRANGE_WITHLABELS_1.default,
+    /**
+     * Gets samples for time series matching a filter with labels (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRevRangeWithLabels: MREVRANGE_WITHLABELS_1.default,
+    /**
+     * Gets samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    MREVRANGE: MREVRANGE_1.default,
+    /**
+     * Gets samples for time series matching a specific filter within a time range (in reverse order)
+     * @param fromTimestamp - Start timestamp for range
+     * @param toTimestamp - End timestamp for range
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    mRevRange: MREVRANGE_1.default,
+    /**
+     * Queries the index for time series matching a specific filter
+     * @param filter - Filter to match time series labels
+     */
+    QUERYINDEX: QUERYINDEX_1.default,
+    /**
+     * Queries the index for time series matching a specific filter
+     * @param filter - Filter to match time series labels
+     */
+    queryIndex: QUERYINDEX_1.default,
+    /**
+     * Gets multi-aggregation samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    RANGE_MULTIAGGR: RANGE_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    rangeMultiAggr: RANGE_MULTIAGGR_1.default,
+    /**
+     * Gets samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    RANGE: RANGE_1.default,
+    /**
+     * Gets samples from a time series within a time range
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    range: RANGE_1.default,
+    /**
+     * Gets multi-aggregation samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    REVRANGE_MULTIAGGR: REVRANGE_MULTIAGGR_1.default,
+    /**
+     * Gets multi-aggregation samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeMultiArguments} function
+     */
+    revRangeMultiAggr: REVRANGE_MULTIAGGR_1.default,
+    /**
+     * Gets samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    REVRANGE: REVRANGE_1.default,
+    /**
+     * Gets samples from a time series within a time range (in reverse order)
+     * @param args - Arguments passed to the {@link transformRangeArguments} function
+     */
+    revRange: REVRANGE_1.default
+};
+//# sourceMappingURL=index.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { default, TIME_SERIES_ENCODING, TimeSeriesEncoding, TIME_SERIES_DUPLICATE_POLICIES, TimeSeriesDuplicatePolicies } from './commands';
+export { TIME_SERIES_AGGREGATION_TYPE, TimeSeriesAggregationType } from './commands/CREATERULE';
+export { TIME_SERIES_BUCKET_TIMESTAMP, TimeSeriesBucketTimestamp } from './commands/RANGE';
+export { TimeSeriesAggregationTypeList, TsRangeMultiAggrOptions } from './commands/RANGE_MULTIAGGR';
+export { TIME_SERIES_REDUCERS, TimeSeriesReducer } from './commands/MRANGE_GROUPBY';
+//# sourceMappingURL=index.d.ts.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,oBAAoB,EAAE,kBAAkB,EACxC,8BAA8B,EAAE,2BAA2B,EAC5D,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAC3F,OAAO,EAAE,6BAA6B,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACpG,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC"}

landvex-report-system/node_modules/@redis/time-series/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.TIME_SERIES_REDUCERS = exports.TIME_SERIES_BUCKET_TIMESTAMP = exports.TIME_SERIES_AGGREGATION_TYPE = exports.TIME_SERIES_DUPLICATE_POLICIES = exports.TIME_SERIES_ENCODING = exports.default = void 0;
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(commands_1).default; } });
+Object.defineProperty(exports, "TIME_SERIES_ENCODING", { enumerable: true, get: function () { return commands_1.TIME_SERIES_ENCODING; } });
+Object.defineProperty(exports, "TIME_SERIES_DUPLICATE_POLICIES", { enumerable: true, get: function () { return commands_1.TIME_SERIES_DUPLICATE_POLICIES; } });
+var CREATERULE_1 = require("./commands/CREATERULE");
+Object.defineProperty(exports, "TIME_SERIES_AGGREGATION_TYPE", { enumerable: true, get: function () { return CREATERULE_1.TIME_SERIES_AGGREGATION_TYPE; } });
+var RANGE_1 = require("./commands/RANGE");
+Object.defineProperty(exports, "TIME_SERIES_BUCKET_TIMESTAMP", { enumerable: true, get: function () { return RANGE_1.TIME_SERIES_BUCKET_TIMESTAMP; } });
+var MRANGE_GROUPBY_1 = require("./commands/MRANGE_GROUPBY");
+Object.defineProperty(exports, "TIME_SERIES_REDUCERS", { enumerable: true, get: function () { return MRANGE_GROUPBY_1.TIME_SERIES_REDUCERS; } });
+//# sourceMappingURL=index.js.map

landvex-report-system/node_modules/@redis/time-series/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":";;;;;;AAAA,uCAIoB;AAHlB,oHAAA,OAAO,OAAA;AACP,gHAAA,oBAAoB,OAAA;AACpB,0HAAA,8BAA8B,OAAA;AAEhC,oDAAgG;AAAvF,0HAAA,4BAA4B,OAAA;AACrC,0CAA2F;AAAlF,qHAAA,4BAA4B,OAAA;AAErC,4DAAoF;AAA3E,sHAAA,oBAAoB,OAAA","sourcesContent":["export {\n  default,\n  TIME_SERIES_ENCODING, TimeSeriesEncoding,\n  TIME_SERIES_DUPLICATE_POLICIES, TimeSeriesDuplicatePolicies\n} from './commands';\nexport { TIME_SERIES_AGGREGATION_TYPE, TimeSeriesAggregationType } from './commands/CREATERULE';\nexport { TIME_SERIES_BUCKET_TIMESTAMP, TimeSeriesBucketTimestamp } from './commands/RANGE';\nexport { TimeSeriesAggregationTypeList, TsRangeMultiAggrOptions } from './commands/RANGE_MULTIAGGR';\nexport { TIME_SERIES_REDUCERS, TimeSeriesReducer } from './commands/MRANGE_GROUPBY';\n"]}

landvex-report-system/node_modules/@redis/time-series/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@redis/time-series",
+  "version": "6.1.0",
+  "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'",
+    "release": "release-it"
+  },
+  "peerDependencies": {
+    "@redis/client": "^6.1.0"
+  },
+  "devDependencies": {
+    "@redis/test-utils": "*"
+  },
+  "engines": {
+    "node": ">= 20.0.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/time-series",
+  "keywords": [
+    "redis",
+    "RedisTimeSeries"
+  ]
+}