123

node_modules/@redis/time-series/dist/commands/ADD.d.ts

@@ -0,0 +1,17 @@
+import { TimeSeriesEncoding, TimeSeriesDuplicatePolicies, Labels, Timestamp } from '.';
+export interface TsIgnoreOptions {
+    MAX_TIME_DIFF: number;
+    MAX_VAL_DIFF: number;
+}
+interface AddOptions {
+    RETENTION?: number;
+    ENCODING?: TimeSeriesEncoding;
+    CHUNK_SIZE?: number;
+    ON_DUPLICATE?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+    IGNORE?: TsIgnoreOptions;
+}
+export declare const FIRST_KEY_INDEX = 1;
+export declare function transformArguments(key: string, timestamp: Timestamp, value: number, options?: AddOptions): Array<string>;
+export declare function transformReply(): number;
+export {};

node_modules/@redis/time-series/dist/commands/ADD.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(key, timestamp, value, options) {
+    const args = [
+        'TS.ADD',
+        key,
+        (0, _1.transformTimestampArgument)(timestamp),
+        value.toString()
+    ];
+    (0, _1.pushRetentionArgument)(args, options?.RETENTION);
+    (0, _1.pushEncodingArgument)(args, options?.ENCODING);
+    (0, _1.pushChunkSizeArgument)(args, options?.CHUNK_SIZE);
+    if (options?.ON_DUPLICATE) {
+        args.push('ON_DUPLICATE', options.ON_DUPLICATE);
+    }
+    (0, _1.pushLabelsArgument)(args, options?.LABELS);
+    (0, _1.pushIgnoreArgument)(args, options?.IGNORE);
+    return args;
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/ALTER.d.ts

@@ -0,0 +1,13 @@
+import { Labels, TimeSeriesDuplicatePolicies } from '.';
+import { TsIgnoreOptions } from './ADD';
+export declare const FIRST_KEY_INDEX = 1;
+interface AlterOptions {
+    RETENTION?: number;
+    CHUNK_SIZE?: number;
+    DUPLICATE_POLICY?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+    IGNORE?: TsIgnoreOptions;
+}
+export declare function transformArguments(key: string, options?: AlterOptions): Array<string>;
+export declare function transformReply(): 'OK';
+export {};

node_modules/@redis/time-series/dist/commands/ALTER.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(key, options) {
+    const args = ['TS.ALTER', key];
+    (0, _1.pushRetentionArgument)(args, options?.RETENTION);
+    (0, _1.pushChunkSizeArgument)(args, options?.CHUNK_SIZE);
+    (0, _1.pushDuplicatePolicy)(args, options?.DUPLICATE_POLICY);
+    (0, _1.pushLabelsArgument)(args, options?.LABELS);
+    (0, _1.pushIgnoreArgument)(args, options?.IGNORE);
+    return args;
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/CREATE.d.ts

@@ -0,0 +1,14 @@
+import { TimeSeriesEncoding, TimeSeriesDuplicatePolicies, Labels } from '.';
+import { TsIgnoreOptions } from './ADD';
+export declare const FIRST_KEY_INDEX = 1;
+interface CreateOptions {
+    RETENTION?: number;
+    ENCODING?: TimeSeriesEncoding;
+    CHUNK_SIZE?: number;
+    DUPLICATE_POLICY?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+    IGNORE?: TsIgnoreOptions;
+}
+export declare function transformArguments(key: string, options?: CreateOptions): Array<string>;
+export declare function transformReply(): 'OK';
+export {};

node_modules/@redis/time-series/dist/commands/CREATE.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(key, options) {
+    const args = ['TS.CREATE', key];
+    (0, _1.pushRetentionArgument)(args, options?.RETENTION);
+    (0, _1.pushEncodingArgument)(args, options?.ENCODING);
+    (0, _1.pushChunkSizeArgument)(args, options?.CHUNK_SIZE);
+    (0, _1.pushDuplicatePolicy)(args, options?.DUPLICATE_POLICY);
+    (0, _1.pushLabelsArgument)(args, options?.LABELS);
+    (0, _1.pushIgnoreArgument)(args, options?.IGNORE);
+    return args;
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/CREATERULE.d.ts

@@ -0,0 +1,4 @@
+import { TimeSeriesAggregationType } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare function transformArguments(sourceKey: string, destinationKey: string, aggregationType: TimeSeriesAggregationType, bucketDuration: number, alignTimestamp?: number): Array<string>;
+export declare function transformReply(): 'OK';

node_modules/@redis/time-series/dist/commands/CREATERULE.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(sourceKey, destinationKey, aggregationType, bucketDuration, alignTimestamp) {
+    const args = [
+        'TS.CREATERULE',
+        sourceKey,
+        destinationKey,
+        'AGGREGATION',
+        aggregationType,
+        bucketDuration.toString()
+    ];
+    if (alignTimestamp) {
+        args.push(alignTimestamp.toString());
+    }
+    return args;
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/DECRBY.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { IncrDecrOptions } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare function transformArguments(key: string, value: number, options?: IncrDecrOptions): RedisCommandArguments;
+export declare function transformReply(): number;

node_modules/@redis/time-series/dist/commands/DECRBY.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(key, value, options) {
+    return (0, _1.transformIncrDecrArguments)('TS.DECRBY', key, value, options);
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/DEL.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { Timestamp } from '.';
+export declare const FIRTS_KEY_INDEX = 1;
+export declare function transformArguments(key: string, fromTimestamp: Timestamp, toTimestamp: Timestamp): RedisCommandArguments;
+export declare function transformReply(): number;

node_modules/@redis/time-series/dist/commands/DEL.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRTS_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRTS_KEY_INDEX = 1;
+function transformArguments(key, fromTimestamp, toTimestamp) {
+    return [
+        'TS.DEL',
+        key,
+        (0, _1.transformTimestampArgument)(fromTimestamp),
+        (0, _1.transformTimestampArgument)(toTimestamp)
+    ];
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/DELETERULE.d.ts

@@ -0,0 +1,3 @@
+export declare const FIRST_KEY_INDEX = 1;
+export declare function transformArguments(sourceKey: string, destinationKey: string): Array<string>;
+export declare function transformReply(): 'OK';

node_modules/@redis/time-series/dist/commands/DELETERULE.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(sourceKey, destinationKey) {
+    return [
+        'TS.DELETERULE',
+        sourceKey,
+        destinationKey
+    ];
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/GET.d.ts

@@ -0,0 +1,10 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { SampleRawReply, SampleReply } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
+interface GetOptions {
+    LATEST?: boolean;
+}
+export declare function transformArguments(key: string, options?: GetOptions): RedisCommandArguments;
+export declare function transformReply(reply: [] | SampleRawReply): null | SampleReply;
+export {};

node_modules/@redis/time-series/dist/commands/GET.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
+function transformArguments(key, options) {
+    return (0, _1.pushLatestArgument)(['TS.GET', key], options?.LATEST);
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    if (reply.length === 0)
+        return null;
+    return (0, _1.transformSampleReply)(reply);
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/INCRBY.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { IncrDecrOptions } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare function transformArguments(key: string, value: number, options?: IncrDecrOptions): RedisCommandArguments;
+export declare function transformReply(): number;

node_modules/@redis/time-series/dist/commands/INCRBY.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(key, value, options) {
+    return (0, _1.transformIncrDecrArguments)('TS.INCRBY', key, value, options);
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/INFO.d.ts

@@ -0,0 +1,52 @@
+import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(key: string): Array<string>;
+export type InfoRawReply = [
+    'totalSamples',
+    number,
+    'memoryUsage',
+    number,
+    'firstTimestamp',
+    number,
+    'lastTimestamp',
+    number,
+    'retentionTime',
+    number,
+    'chunkCount',
+    number,
+    'chunkSize',
+    number,
+    'chunkType',
+    string,
+    'duplicatePolicy',
+    TimeSeriesDuplicatePolicies | null,
+    'labels',
+    Array<[name: string, value: string]>,
+    'sourceKey',
+    string | null,
+    'rules',
+    Array<[key: string, timeBucket: number, aggregationType: TimeSeriesAggregationType]>
+];
+export interface InfoReply {
+    totalSamples: number;
+    memoryUsage: number;
+    firstTimestamp: number;
+    lastTimestamp: number;
+    retentionTime: number;
+    chunkCount: number;
+    chunkSize: number;
+    chunkType: string;
+    duplicatePolicy: TimeSeriesDuplicatePolicies | null;
+    labels: Array<{
+        name: string;
+        value: string;
+    }>;
+    sourceKey: string | null;
+    rules: Array<{
+        key: string;
+        timeBucket: number;
+        aggregationType: TimeSeriesAggregationType;
+    }>;
+}
+export declare function transformReply(reply: InfoRawReply): InfoReply;

node_modules/@redis/time-series/dist/commands/INFO.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
+function transformArguments(key) {
+    return ['TS.INFO', key];
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return {
+        totalSamples: reply[1],
+        memoryUsage: reply[3],
+        firstTimestamp: reply[5],
+        lastTimestamp: reply[7],
+        retentionTime: reply[9],
+        chunkCount: reply[11],
+        chunkSize: reply[13],
+        chunkType: reply[15],
+        duplicatePolicy: reply[17],
+        labels: reply[19].map(([name, value]) => ({
+            name,
+            value
+        })),
+        sourceKey: reply[21],
+        rules: reply[23].map(([key, timeBucket, aggregationType]) => ({
+            key,
+            timeBucket,
+            aggregationType
+        }))
+    };
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/INFO_DEBUG.d.ts

@@ -0,0 +1,32 @@
+import { InfoRawReply, InfoReply } from './INFO';
+export { IS_READ_ONLY, FIRST_KEY_INDEX } from './INFO';
+export declare function transformArguments(key: string): Array<string>;
+type InfoDebugRawReply = [
+    ...InfoRawReply,
+    'keySelfName',
+    string,
+    'chunks',
+    Array<[
+        'startTimestamp',
+        number,
+        'endTimestamp',
+        number,
+        'samples',
+        number,
+        'size',
+        number,
+        'bytesPerSample',
+        string
+    ]>
+];
+interface InfoDebugReply extends InfoReply {
+    keySelfName: string;
+    chunks: Array<{
+        startTimestamp: number;
+        endTimestamp: number;
+        samples: number;
+        size: number;
+        bytesPerSample: string;
+    }>;
+}
+export declare function transformReply(rawReply: InfoDebugRawReply): InfoDebugReply;

node_modules/@redis/time-series/dist/commands/INFO_DEBUG.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.FIRST_KEY_INDEX = exports.IS_READ_ONLY = void 0;
+const INFO_1 = require("./INFO");
+var INFO_2 = require("./INFO");
+Object.defineProperty(exports, "IS_READ_ONLY", { enumerable: true, get: function () { return INFO_2.IS_READ_ONLY; } });
+Object.defineProperty(exports, "FIRST_KEY_INDEX", { enumerable: true, get: function () { return INFO_2.FIRST_KEY_INDEX; } });
+function transformArguments(key) {
+    const args = (0, INFO_1.transformArguments)(key);
+    args.push('DEBUG');
+    return args;
+}
+exports.transformArguments = transformArguments;
+function transformReply(rawReply) {
+    const reply = (0, INFO_1.transformReply)(rawReply);
+    reply.keySelfName = rawReply[25];
+    reply.chunks = rawReply[27].map(chunk => ({
+        startTimestamp: chunk[1],
+        endTimestamp: chunk[3],
+        samples: chunk[5],
+        size: chunk[7],
+        bytesPerSample: chunk[9]
+    }));
+    return reply;
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/MADD.d.ts

@@ -0,0 +1,10 @@
+import { Timestamp } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+interface MAddSample {
+    key: string;
+    timestamp: Timestamp;
+    value: number;
+}
+export declare function transformArguments(toAdd: Array<MAddSample>): Array<string>;
+export declare function transformReply(): Array<number>;
+export {};

node_modules/@redis/time-series/dist/commands/MADD.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+function transformArguments(toAdd) {
+    const args = ['TS.MADD'];
+    for (const { key, timestamp, value } of toAdd) {
+        args.push(key, (0, _1.transformTimestampArgument)(timestamp), value.toString());
+    }
+    return args;
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/MGET.d.ts

@@ -0,0 +1,17 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { Filter, RawLabels, SampleRawReply, SampleReply } from '.';
+export declare const IS_READ_ONLY = true;
+export interface MGetOptions {
+    LATEST?: boolean;
+}
+export declare function transformArguments(filter: Filter, options?: MGetOptions): RedisCommandArguments;
+export type MGetRawReply = Array<[
+    key: string,
+    labels: RawLabels,
+    sample: SampleRawReply
+]>;
+export interface MGetReply {
+    key: string;
+    sample: SampleReply;
+}
+export declare function transformReply(reply: MGetRawReply): Array<MGetReply>;

node_modules/@redis/time-series/dist/commands/MGET.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(filter, options) {
+    const args = (0, _1.pushLatestArgument)(['TS.MGET'], options?.LATEST);
+    return (0, _1.pushFilterArgument)(args, filter);
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return reply.map(([key, _, sample]) => ({
+        key,
+        sample: (0, _1.transformSampleReply)(sample)
+    }));
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/MGET_WITHLABELS.d.ts

@@ -0,0 +1,13 @@
+import { SelectedLabels, Labels, Filter } from '.';
+import { MGetOptions, MGetRawReply, MGetReply } from './MGET';
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+export declare const IS_READ_ONLY = true;
+interface MGetWithLabelsOptions extends MGetOptions {
+    SELECTED_LABELS?: SelectedLabels;
+}
+export declare function transformArguments(filter: Filter, options?: MGetWithLabelsOptions): RedisCommandArguments;
+export interface MGetWithLabelsReply extends MGetReply {
+    labels: Labels;
+}
+export declare function transformReply(reply: MGetRawReply): Array<MGetWithLabelsReply>;
+export {};

node_modules/@redis/time-series/dist/commands/MGET_WITHLABELS.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(filter, options) {
+    const args = (0, _1.pushWithLabelsArgument)(['TS.MGET'], options?.SELECTED_LABELS);
+    return (0, _1.pushFilterArgument)(args, filter);
+}
+exports.transformArguments = transformArguments;
+;
+function transformReply(reply) {
+    return reply.map(([key, labels, sample]) => ({
+        key,
+        labels: (0, _1.transformLablesReply)(labels),
+        sample: (0, _1.transformSampleReply)(sample)
+    }));
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/MRANGE.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { MRangeOptions, Timestamp, Filter } from '.';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(fromTimestamp: Timestamp, toTimestamp: Timestamp, filters: Filter, options?: MRangeOptions): RedisCommandArguments;
+export { transformMRangeReply as transformReply } from '.';

node_modules/@redis/time-series/dist/commands/MRANGE.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(fromTimestamp, toTimestamp, filters, options) {
+    return (0, _1.pushMRangeArguments)(['TS.MRANGE'], fromTimestamp, toTimestamp, filters, options);
+}
+exports.transformArguments = transformArguments;
+var _2 = require(".");
+Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return _2.transformMRangeReply; } });

node_modules/@redis/time-series/dist/commands/MRANGE_WITHLABELS.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { Timestamp, MRangeWithLabelsOptions } from '.';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(fromTimestamp: Timestamp, toTimestamp: Timestamp, filters: string | Array<string>, options?: MRangeWithLabelsOptions): RedisCommandArguments;
+export { transformMRangeWithLabelsReply as transformReply } from '.';

node_modules/@redis/time-series/dist/commands/MRANGE_WITHLABELS.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(fromTimestamp, toTimestamp, filters, options) {
+    return (0, _1.pushMRangeWithLabelsArguments)(['TS.MRANGE'], fromTimestamp, toTimestamp, filters, options);
+}
+exports.transformArguments = transformArguments;
+var _2 = require(".");
+Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return _2.transformMRangeWithLabelsReply; } });

node_modules/@redis/time-series/dist/commands/MREVRANGE.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { MRangeOptions, Timestamp, Filter } from '.';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(fromTimestamp: Timestamp, toTimestamp: Timestamp, filters: Filter, options?: MRangeOptions): RedisCommandArguments;
+export { transformMRangeReply as transformReply } from '.';

node_modules/@redis/time-series/dist/commands/MREVRANGE.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(fromTimestamp, toTimestamp, filters, options) {
+    return (0, _1.pushMRangeArguments)(['TS.MREVRANGE'], fromTimestamp, toTimestamp, filters, options);
+}
+exports.transformArguments = transformArguments;
+var _2 = require(".");
+Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return _2.transformMRangeReply; } });

node_modules/@redis/time-series/dist/commands/MREVRANGE_WITHLABELS.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { Timestamp, MRangeWithLabelsOptions, Filter } from '.';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(fromTimestamp: Timestamp, toTimestamp: Timestamp, filters: Filter, options?: MRangeWithLabelsOptions): RedisCommandArguments;
+export { transformMRangeWithLabelsReply as transformReply } from '.';

node_modules/@redis/time-series/dist/commands/MREVRANGE_WITHLABELS.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const _1 = require(".");
+exports.IS_READ_ONLY = true;
+function transformArguments(fromTimestamp, toTimestamp, filters, options) {
+    return (0, _1.pushMRangeWithLabelsArguments)(['TS.MREVRANGE'], fromTimestamp, toTimestamp, filters, options);
+}
+exports.transformArguments = transformArguments;
+var _2 = require(".");
+Object.defineProperty(exports, "transformReply", { enumerable: true, get: function () { return _2.transformMRangeWithLabelsReply; } });

node_modules/@redis/time-series/dist/commands/QUERYINDEX.d.ts

@@ -0,0 +1,5 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { Filter } from '.';
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(filter: Filter): RedisCommandArguments;
+export declare function transformReply(): Array<string>;

node_modules/@redis/time-series/dist/commands/QUERYINDEX.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformArguments = exports.IS_READ_ONLY = void 0;
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.IS_READ_ONLY = true;
+function transformArguments(filter) {
+    return (0, generic_transformers_1.pushVerdictArguments)(['TS.QUERYINDEX'], filter);
+}
+exports.transformArguments = transformArguments;

node_modules/@redis/time-series/dist/commands/RANGE.d.ts

@@ -0,0 +1,6 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { RangeOptions, Timestamp, SampleRawReply, SampleReply } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(key: string, fromTimestamp: Timestamp, toTimestamp: Timestamp, options?: RangeOptions): RedisCommandArguments;
+export declare function transformReply(reply: Array<SampleRawReply>): Array<SampleReply>;

node_modules/@redis/time-series/dist/commands/RANGE.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
+function transformArguments(key, fromTimestamp, toTimestamp, options) {
+    return (0, _1.pushRangeArguments)(['TS.RANGE', key], fromTimestamp, toTimestamp, options);
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return (0, _1.transformRangeReply)(reply);
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/REVRANGE.d.ts

@@ -0,0 +1,6 @@
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+import { RangeOptions, Timestamp, SampleRawReply, SampleReply } from '.';
+export declare const FIRST_KEY_INDEX = 1;
+export declare const IS_READ_ONLY = true;
+export declare function transformArguments(key: string, fromTimestamp: Timestamp, toTimestamp: Timestamp, options?: RangeOptions): RedisCommandArguments;
+export declare function transformReply(reply: Array<SampleRawReply>): Array<SampleReply>;

node_modules/@redis/time-series/dist/commands/REVRANGE.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
+const _1 = require(".");
+exports.FIRST_KEY_INDEX = 1;
+exports.IS_READ_ONLY = true;
+function transformArguments(key, fromTimestamp, toTimestamp, options) {
+    return (0, _1.pushRangeArguments)(['TS.REVRANGE', key], fromTimestamp, toTimestamp, options);
+}
+exports.transformArguments = transformArguments;
+function transformReply(reply) {
+    return (0, _1.transformRangeReply)(reply);
+}
+exports.transformReply = transformReply;

node_modules/@redis/time-series/dist/commands/index.d.ts

@@ -0,0 +1,193 @@
+import * as ADD from './ADD';
+import * as ALTER from './ALTER';
+import * as CREATE from './CREATE';
+import * as CREATERULE from './CREATERULE';
+import * as DECRBY from './DECRBY';
+import * as DEL from './DEL';
+import * as DELETERULE from './DELETERULE';
+import * as GET from './GET';
+import * as INCRBY from './INCRBY';
+import * as INFO_DEBUG from './INFO_DEBUG';
+import * as INFO from './INFO';
+import * as MADD from './MADD';
+import * as MGET from './MGET';
+import * as MGET_WITHLABELS from './MGET_WITHLABELS';
+import * as QUERYINDEX from './QUERYINDEX';
+import * as RANGE from './RANGE';
+import * as REVRANGE from './REVRANGE';
+import * as MRANGE from './MRANGE';
+import * as MRANGE_WITHLABELS from './MRANGE_WITHLABELS';
+import * as MREVRANGE from './MREVRANGE';
+import * as MREVRANGE_WITHLABELS from './MREVRANGE_WITHLABELS';
+import { RedisCommandArguments } from '@redis/client/dist/lib/commands';
+declare const _default: {
+    ADD: typeof ADD;
+    add: typeof ADD;
+    ALTER: typeof ALTER;
+    alter: typeof ALTER;
+    CREATE: typeof CREATE;
+    create: typeof CREATE;
+    CREATERULE: typeof CREATERULE;
+    createRule: typeof CREATERULE;
+    DECRBY: typeof DECRBY;
+    decrBy: typeof DECRBY;
+    DEL: typeof DEL;
+    del: typeof DEL;
+    DELETERULE: typeof DELETERULE;
+    deleteRule: typeof DELETERULE;
+    GET: typeof GET;
+    get: typeof GET;
+    INCRBY: typeof INCRBY;
+    incrBy: typeof INCRBY;
+    INFO_DEBUG: typeof INFO_DEBUG;
+    infoDebug: typeof INFO_DEBUG;
+    INFO: typeof INFO;
+    info: typeof INFO;
+    MADD: typeof MADD;
+    mAdd: typeof MADD;
+    MGET: typeof MGET;
+    mGet: typeof MGET;
+    MGET_WITHLABELS: typeof MGET_WITHLABELS;
+    mGetWithLabels: typeof MGET_WITHLABELS;
+    QUERYINDEX: typeof QUERYINDEX;
+    queryIndex: typeof QUERYINDEX;
+    RANGE: typeof RANGE;
+    range: typeof RANGE;
+    REVRANGE: typeof REVRANGE;
+    revRange: typeof REVRANGE;
+    MRANGE: typeof MRANGE;
+    mRange: typeof MRANGE;
+    MRANGE_WITHLABELS: typeof MRANGE_WITHLABELS;
+    mRangeWithLabels: typeof MRANGE_WITHLABELS;
+    MREVRANGE: typeof MREVRANGE;
+    mRevRange: typeof MREVRANGE;
+    MREVRANGE_WITHLABELS: typeof MREVRANGE_WITHLABELS;
+    mRevRangeWithLabels: typeof MREVRANGE_WITHLABELS;
+};
+export default _default;
+export declare enum TimeSeriesAggregationType {
+    AVG = "AVG",
+    AVERAGE = "AVG",
+    FIRST = "FIRST",
+    LAST = "LAST",
+    MIN = "MIN",
+    MINIMUM = "MIN",
+    MAX = "MAX",
+    MAXIMUM = "MAX",
+    SUM = "SUM",
+    RANGE = "RANGE",
+    COUNT = "COUNT",
+    STD_P = "STD.P",
+    STD_S = "STD.S",
+    VAR_P = "VAR.P",
+    VAR_S = "VAR.S",
+    TWA = "TWA"
+}
+export declare enum TimeSeriesDuplicatePolicies {
+    BLOCK = "BLOCK",
+    FIRST = "FIRST",
+    LAST = "LAST",
+    MIN = "MIN",
+    MAX = "MAX",
+    SUM = "SUM"
+}
+export declare enum TimeSeriesReducers {
+    AVG = "AVG",
+    SUM = "SUM",
+    MIN = "MIN",
+    MINIMUM = "MIN",
+    MAX = "MAX",
+    MAXIMUM = "MAX",
+    RANGE = "range",
+    COUNT = "COUNT",
+    STD_P = "STD.P",
+    STD_S = "STD.S",
+    VAR_P = "VAR.P",
+    VAR_S = "VAR.S"
+}
+export type Timestamp = number | Date | string;
+export declare function transformTimestampArgument(timestamp: Timestamp): string;
+export declare function pushIgnoreArgument(args: RedisCommandArguments, ignore?: ADD.TsIgnoreOptions): void;
+export declare function pushRetentionArgument(args: RedisCommandArguments, retention?: number): RedisCommandArguments;
+export declare enum TimeSeriesEncoding {
+    COMPRESSED = "COMPRESSED",
+    UNCOMPRESSED = "UNCOMPRESSED"
+}
+export declare function pushEncodingArgument(args: RedisCommandArguments, encoding?: TimeSeriesEncoding): RedisCommandArguments;
+export declare function pushChunkSizeArgument(args: RedisCommandArguments, chunkSize?: number): RedisCommandArguments;
+export declare function pushDuplicatePolicy(args: RedisCommandArguments, duplicatePolicy?: TimeSeriesDuplicatePolicies): RedisCommandArguments;
+export type RawLabels = Array<[label: string, value: string]>;
+export type Labels = {
+    [label: string]: string;
+};
+export declare function transformLablesReply(reply: RawLabels): Labels;
+export declare function pushLabelsArgument(args: RedisCommandArguments, labels?: Labels): RedisCommandArguments;
+export interface IncrDecrOptions {
+    TIMESTAMP?: Timestamp;
+    RETENTION?: number;
+    UNCOMPRESSED?: boolean;
+    CHUNK_SIZE?: number;
+    LABELS?: Labels;
+}
+export declare function transformIncrDecrArguments(command: 'TS.INCRBY' | 'TS.DECRBY', key: string, value: number, options?: IncrDecrOptions): RedisCommandArguments;
+export type SampleRawReply = [timestamp: number, value: string];
+export interface SampleReply {
+    timestamp: number;
+    value: number;
+}
+export declare function transformSampleReply(reply: SampleRawReply): SampleReply;
+export declare enum TimeSeriesBucketTimestamp {
+    LOW = "-",
+    HIGH = "+",
+    MID = "~"
+}
+export interface RangeOptions {
+    LATEST?: boolean;
+    FILTER_BY_TS?: Array<Timestamp>;
+    FILTER_BY_VALUE?: {
+        min: number;
+        max: number;
+    };
+    COUNT?: number;
+    ALIGN?: Timestamp;
+    AGGREGATION?: {
+        type: TimeSeriesAggregationType;
+        timeBucket: Timestamp;
+        BUCKETTIMESTAMP?: TimeSeriesBucketTimestamp;
+        EMPTY?: boolean;
+    };
+}
+export declare function pushRangeArguments(args: RedisCommandArguments, fromTimestamp: Timestamp, toTimestamp: Timestamp, options?: RangeOptions): RedisCommandArguments;
+interface MRangeGroupBy {
+    label: string;
+    reducer: TimeSeriesReducers;
+}
+export declare function pushMRangeGroupByArguments(args: RedisCommandArguments, groupBy?: MRangeGroupBy): RedisCommandArguments;
+export type Filter = string | Array<string>;
+export declare function pushFilterArgument(args: RedisCommandArguments, filter: string | Array<string>): RedisCommandArguments;
+export interface MRangeOptions extends RangeOptions {
+    GROUPBY?: MRangeGroupBy;
+}
+export declare function pushMRangeArguments(args: RedisCommandArguments, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: Filter, options?: MRangeOptions): RedisCommandArguments;
+export type SelectedLabels = string | Array<string>;
+export declare function pushWithLabelsArgument(args: RedisCommandArguments, selectedLabels?: SelectedLabels): RedisCommandArguments;
+export interface MRangeWithLabelsOptions extends MRangeOptions {
+    SELECTED_LABELS?: SelectedLabels;
+}
+export declare function pushMRangeWithLabelsArguments(args: RedisCommandArguments, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: Filter, options?: MRangeWithLabelsOptions): RedisCommandArguments;
+export declare function transformRangeReply(reply: Array<SampleRawReply>): Array<SampleReply>;
+type MRangeRawReply = Array<[
+    key: string,
+    labels: RawLabels,
+    samples: Array<SampleRawReply>
+]>;
+interface MRangeReplyItem {
+    key: string;
+    samples: Array<SampleReply>;
+}
+export declare function transformMRangeReply(reply: MRangeRawReply): Array<MRangeReplyItem>;
+export interface MRangeWithLabelsReplyItem extends MRangeReplyItem {
+    labels: Labels;
+}
+export declare function transformMRangeWithLabelsReply(reply: MRangeRawReply): Array<MRangeWithLabelsReplyItem>;
+export declare function pushLatestArgument(args: RedisCommandArguments, latest?: boolean): RedisCommandArguments;

node_modules/@redis/time-series/dist/commands/index.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushLatestArgument = exports.transformMRangeWithLabelsReply = exports.transformMRangeReply = exports.transformRangeReply = exports.pushMRangeWithLabelsArguments = exports.pushWithLabelsArgument = exports.pushMRangeArguments = exports.pushFilterArgument = exports.pushMRangeGroupByArguments = exports.pushRangeArguments = exports.TimeSeriesBucketTimestamp = exports.transformSampleReply = exports.transformIncrDecrArguments = exports.pushLabelsArgument = exports.transformLablesReply = exports.pushDuplicatePolicy = exports.pushChunkSizeArgument = exports.pushEncodingArgument = exports.TimeSeriesEncoding = exports.pushRetentionArgument = exports.pushIgnoreArgument = exports.transformTimestampArgument = exports.TimeSeriesReducers = exports.TimeSeriesDuplicatePolicies = exports.TimeSeriesAggregationType = void 0;
+const ADD = require("./ADD");
+const ALTER = require("./ALTER");
+const CREATE = require("./CREATE");
+const CREATERULE = require("./CREATERULE");
+const DECRBY = require("./DECRBY");
+const DEL = require("./DEL");
+const DELETERULE = require("./DELETERULE");
+const GET = require("./GET");
+const INCRBY = require("./INCRBY");
+const INFO_DEBUG = require("./INFO_DEBUG");
+const INFO = require("./INFO");
+const MADD = require("./MADD");
+const MGET = require("./MGET");
+const MGET_WITHLABELS = require("./MGET_WITHLABELS");
+const QUERYINDEX = require("./QUERYINDEX");
+const RANGE = require("./RANGE");
+const REVRANGE = require("./REVRANGE");
+const MRANGE = require("./MRANGE");
+const MRANGE_WITHLABELS = require("./MRANGE_WITHLABELS");
+const MREVRANGE = require("./MREVRANGE");
+const MREVRANGE_WITHLABELS = require("./MREVRANGE_WITHLABELS");
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    ADD,
+    add: ADD,
+    ALTER,
+    alter: ALTER,
+    CREATE,
+    create: CREATE,
+    CREATERULE,
+    createRule: CREATERULE,
+    DECRBY,
+    decrBy: DECRBY,
+    DEL,
+    del: DEL,
+    DELETERULE,
+    deleteRule: DELETERULE,
+    GET,
+    get: GET,
+    INCRBY,
+    incrBy: INCRBY,
+    INFO_DEBUG,
+    infoDebug: INFO_DEBUG,
+    INFO,
+    info: INFO,
+    MADD,
+    mAdd: MADD,
+    MGET,
+    mGet: MGET,
+    MGET_WITHLABELS,
+    mGetWithLabels: MGET_WITHLABELS,
+    QUERYINDEX,
+    queryIndex: QUERYINDEX,
+    RANGE,
+    range: RANGE,
+    REVRANGE,
+    revRange: REVRANGE,
+    MRANGE,
+    mRange: MRANGE,
+    MRANGE_WITHLABELS,
+    mRangeWithLabels: MRANGE_WITHLABELS,
+    MREVRANGE,
+    mRevRange: MREVRANGE,
+    MREVRANGE_WITHLABELS,
+    mRevRangeWithLabels: MREVRANGE_WITHLABELS
+};
+var TimeSeriesAggregationType;
+(function (TimeSeriesAggregationType) {
+    TimeSeriesAggregationType["AVG"] = "AVG";
+    // @deprecated
+    TimeSeriesAggregationType["AVERAGE"] = "AVG";
+    TimeSeriesAggregationType["FIRST"] = "FIRST";
+    TimeSeriesAggregationType["LAST"] = "LAST";
+    TimeSeriesAggregationType["MIN"] = "MIN";
+    // @deprecated
+    TimeSeriesAggregationType["MINIMUM"] = "MIN";
+    TimeSeriesAggregationType["MAX"] = "MAX";
+    // @deprecated
+    TimeSeriesAggregationType["MAXIMUM"] = "MAX";
+    TimeSeriesAggregationType["SUM"] = "SUM";
+    TimeSeriesAggregationType["RANGE"] = "RANGE";
+    TimeSeriesAggregationType["COUNT"] = "COUNT";
+    TimeSeriesAggregationType["STD_P"] = "STD.P";
+    TimeSeriesAggregationType["STD_S"] = "STD.S";
+    TimeSeriesAggregationType["VAR_P"] = "VAR.P";
+    TimeSeriesAggregationType["VAR_S"] = "VAR.S";
+    TimeSeriesAggregationType["TWA"] = "TWA";
+})(TimeSeriesAggregationType || (exports.TimeSeriesAggregationType = TimeSeriesAggregationType = {}));
+var TimeSeriesDuplicatePolicies;
+(function (TimeSeriesDuplicatePolicies) {
+    TimeSeriesDuplicatePolicies["BLOCK"] = "BLOCK";
+    TimeSeriesDuplicatePolicies["FIRST"] = "FIRST";
+    TimeSeriesDuplicatePolicies["LAST"] = "LAST";
+    TimeSeriesDuplicatePolicies["MIN"] = "MIN";
+    TimeSeriesDuplicatePolicies["MAX"] = "MAX";
+    TimeSeriesDuplicatePolicies["SUM"] = "SUM";
+})(TimeSeriesDuplicatePolicies || (exports.TimeSeriesDuplicatePolicies = TimeSeriesDuplicatePolicies = {}));
+var TimeSeriesReducers;
+(function (TimeSeriesReducers) {
+    TimeSeriesReducers["AVG"] = "AVG";
+    TimeSeriesReducers["SUM"] = "SUM";
+    TimeSeriesReducers["MIN"] = "MIN";
+    // @deprecated
+    TimeSeriesReducers["MINIMUM"] = "MIN";
+    TimeSeriesReducers["MAX"] = "MAX";
+    // @deprecated
+    TimeSeriesReducers["MAXIMUM"] = "MAX";
+    TimeSeriesReducers["RANGE"] = "range";
+    TimeSeriesReducers["COUNT"] = "COUNT";
+    TimeSeriesReducers["STD_P"] = "STD.P";
+    TimeSeriesReducers["STD_S"] = "STD.S";
+    TimeSeriesReducers["VAR_P"] = "VAR.P";
+    TimeSeriesReducers["VAR_S"] = "VAR.S";
+})(TimeSeriesReducers || (exports.TimeSeriesReducers = TimeSeriesReducers = {}));
+function transformTimestampArgument(timestamp) {
+    if (typeof timestamp === 'string')
+        return timestamp;
+    return (typeof timestamp === 'number' ?
+        timestamp :
+        timestamp.getTime()).toString();
+}
+exports.transformTimestampArgument = transformTimestampArgument;
+function pushIgnoreArgument(args, ignore) {
+    if (ignore !== undefined) {
+        args.push('IGNORE', ignore.MAX_TIME_DIFF.toString(), ignore.MAX_VAL_DIFF.toString());
+    }
+}
+exports.pushIgnoreArgument = pushIgnoreArgument;
+function pushRetentionArgument(args, retention) {
+    if (retention !== undefined) {
+        args.push('RETENTION', retention.toString());
+    }
+    return args;
+}
+exports.pushRetentionArgument = pushRetentionArgument;
+var TimeSeriesEncoding;
+(function (TimeSeriesEncoding) {
+    TimeSeriesEncoding["COMPRESSED"] = "COMPRESSED";
+    TimeSeriesEncoding["UNCOMPRESSED"] = "UNCOMPRESSED";
+})(TimeSeriesEncoding || (exports.TimeSeriesEncoding = TimeSeriesEncoding = {}));
+function pushEncodingArgument(args, encoding) {
+    if (encoding !== undefined) {
+        args.push('ENCODING', encoding);
+    }
+    return args;
+}
+exports.pushEncodingArgument = pushEncodingArgument;
+function pushChunkSizeArgument(args, chunkSize) {
+    if (chunkSize !== undefined) {
+        args.push('CHUNK_SIZE', chunkSize.toString());
+    }
+    return args;
+}
+exports.pushChunkSizeArgument = pushChunkSizeArgument;
+function pushDuplicatePolicy(args, duplicatePolicy) {
+    if (duplicatePolicy !== undefined) {
+        args.push('DUPLICATE_POLICY', duplicatePolicy);
+    }
+    return args;
+}
+exports.pushDuplicatePolicy = pushDuplicatePolicy;
+function transformLablesReply(reply) {
+    const labels = {};
+    for (const [key, value] of reply) {
+        labels[key] = value;
+    }
+    return labels;
+}
+exports.transformLablesReply = transformLablesReply;
+function pushLabelsArgument(args, labels) {
+    if (labels) {
+        args.push('LABELS');
+        for (const [label, value] of Object.entries(labels)) {
+            args.push(label, value);
+        }
+    }
+    return args;
+}
+exports.pushLabelsArgument = pushLabelsArgument;
+function transformIncrDecrArguments(command, key, value, options) {
+    const args = [
+        command,
+        key,
+        value.toString()
+    ];
+    if (options?.TIMESTAMP !== undefined && options?.TIMESTAMP !== null) {
+        args.push('TIMESTAMP', transformTimestampArgument(options.TIMESTAMP));
+    }
+    pushRetentionArgument(args, options?.RETENTION);
+    if (options?.UNCOMPRESSED) {
+        args.push('UNCOMPRESSED');
+    }
+    pushChunkSizeArgument(args, options?.CHUNK_SIZE);
+    pushLabelsArgument(args, options?.LABELS);
+    return args;
+}
+exports.transformIncrDecrArguments = transformIncrDecrArguments;
+function transformSampleReply(reply) {
+    return {
+        timestamp: reply[0],
+        value: Number(reply[1])
+    };
+}
+exports.transformSampleReply = transformSampleReply;
+var TimeSeriesBucketTimestamp;
+(function (TimeSeriesBucketTimestamp) {
+    TimeSeriesBucketTimestamp["LOW"] = "-";
+    TimeSeriesBucketTimestamp["HIGH"] = "+";
+    TimeSeriesBucketTimestamp["MID"] = "~";
+})(TimeSeriesBucketTimestamp || (exports.TimeSeriesBucketTimestamp = TimeSeriesBucketTimestamp = {}));
+function pushRangeArguments(args, fromTimestamp, toTimestamp, options) {
+    args.push(transformTimestampArgument(fromTimestamp), transformTimestampArgument(toTimestamp));
+    pushLatestArgument(args, options?.LATEST);
+    if (options?.FILTER_BY_TS) {
+        args.push('FILTER_BY_TS');
+        for (const ts of options.FILTER_BY_TS) {
+            args.push(transformTimestampArgument(ts));
+        }
+    }
+    if (options?.FILTER_BY_VALUE) {
+        args.push('FILTER_BY_VALUE', options.FILTER_BY_VALUE.min.toString(), options.FILTER_BY_VALUE.max.toString());
+    }
+    if (options?.COUNT) {
+        args.push('COUNT', options.COUNT.toString());
+    }
+    if (options?.ALIGN) {
+        args.push('ALIGN', transformTimestampArgument(options.ALIGN));
+    }
+    if (options?.AGGREGATION) {
+        args.push('AGGREGATION', options.AGGREGATION.type, transformTimestampArgument(options.AGGREGATION.timeBucket));
+        if (options.AGGREGATION.BUCKETTIMESTAMP) {
+            args.push('BUCKETTIMESTAMP', options.AGGREGATION.BUCKETTIMESTAMP);
+        }
+        if (options.AGGREGATION.EMPTY) {
+            args.push('EMPTY');
+        }
+    }
+    return args;
+}
+exports.pushRangeArguments = pushRangeArguments;
+function pushMRangeGroupByArguments(args, groupBy) {
+    if (groupBy) {
+        args.push('GROUPBY', groupBy.label, 'REDUCE', groupBy.reducer);
+    }
+    return args;
+}
+exports.pushMRangeGroupByArguments = pushMRangeGroupByArguments;
+function pushFilterArgument(args, filter) {
+    args.push('FILTER');
+    return (0, generic_transformers_1.pushVerdictArguments)(args, filter);
+}
+exports.pushFilterArgument = pushFilterArgument;
+function pushMRangeArguments(args, fromTimestamp, toTimestamp, filter, options) {
+    args = pushRangeArguments(args, fromTimestamp, toTimestamp, options);
+    args = pushFilterArgument(args, filter);
+    return pushMRangeGroupByArguments(args, options?.GROUPBY);
+}
+exports.pushMRangeArguments = pushMRangeArguments;
+function pushWithLabelsArgument(args, selectedLabels) {
+    if (!selectedLabels) {
+        args.push('WITHLABELS');
+    }
+    else {
+        args.push('SELECTED_LABELS');
+        args = (0, generic_transformers_1.pushVerdictArguments)(args, selectedLabels);
+    }
+    return args;
+}
+exports.pushWithLabelsArgument = pushWithLabelsArgument;
+function pushMRangeWithLabelsArguments(args, fromTimestamp, toTimestamp, filter, options) {
+    args = pushRangeArguments(args, fromTimestamp, toTimestamp, options);
+    args = pushWithLabelsArgument(args, options?.SELECTED_LABELS);
+    args = pushFilterArgument(args, filter);
+    return pushMRangeGroupByArguments(args, options?.GROUPBY);
+}
+exports.pushMRangeWithLabelsArguments = pushMRangeWithLabelsArguments;
+function transformRangeReply(reply) {
+    return reply.map(transformSampleReply);
+}
+exports.transformRangeReply = transformRangeReply;
+function transformMRangeReply(reply) {
+    const args = [];
+    for (const [key, _, sample] of reply) {
+        args.push({
+            key,
+            samples: sample.map(transformSampleReply)
+        });
+    }
+    return args;
+}
+exports.transformMRangeReply = transformMRangeReply;
+function transformMRangeWithLabelsReply(reply) {
+    const args = [];
+    for (const [key, labels, samples] of reply) {
+        args.push({
+            key,
+            labels: transformLablesReply(labels),
+            samples: samples.map(transformSampleReply)
+        });
+    }
+    return args;
+}
+exports.transformMRangeWithLabelsReply = transformMRangeWithLabelsReply;
+function pushLatestArgument(args, latest) {
+    if (latest) {
+        args.push('LATEST');
+    }
+    return args;
+}
+exports.pushLatestArgument = pushLatestArgument;