@redis/time-series 1.0.5 → 2.0.0-next.1

package/dist/lib/commands/ADD.d.ts

@@ -0,0 +1,16 @@
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+import { TimeSeriesEncoding, TimeSeriesDuplicatePolicies, Labels, Timestamp } from '.';
+export interface TsAddOptions {
+    RETENTION?: number;
+    ENCODING?: TimeSeriesEncoding;
+    CHUNK_SIZE?: number;
+    ON_DUPLICATE?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, key: RedisArgument, timestamp: Timestamp, value: number, options?: TsAddOptions) => RedisArgument[];
+    readonly transformReply: () => NumberReply;
+};
+export default _default;

package/dist/lib/commands/ADD.js

@@ -0,0 +1,22 @@
+import { transformTimestampArgument, pushRetentionArgument, pushEncodingArgument, pushChunkSizeArgument, pushLabelsArgument } from '.';
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, timestamp, value, options) {
+        const args = [
+            'TS.ADD',
+            key,
+            transformTimestampArgument(timestamp),
+            value.toString()
+        ];
+        pushRetentionArgument(args, options?.RETENTION);
+        pushEncodingArgument(args, options?.ENCODING);
+        pushChunkSizeArgument(args, options?.CHUNK_SIZE);
+        if (options?.ON_DUPLICATE) {
+            args.push('ON_DUPLICATE', options.ON_DUPLICATE);
+        }
+        pushLabelsArgument(args, options?.LABELS);
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/ALTER.d.ts

@@ -0,0 +1,10 @@
+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'>;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, key: RedisArgument, options?: TsAlterOptions) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/ALTER.js

@@ -0,0 +1,14 @@
+import { pushRetentionArgument, pushChunkSizeArgument, pushDuplicatePolicy, pushLabelsArgument } from '.';
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, options) {
+        const args = ['TS.ALTER', key];
+        pushRetentionArgument(args, options?.RETENTION);
+        pushChunkSizeArgument(args, options?.CHUNK_SIZE);
+        pushDuplicatePolicy(args, options?.DUPLICATE_POLICY);
+        pushLabelsArgument(args, options?.LABELS);
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/CREATE.d.ts

@@ -0,0 +1,16 @@
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+import { TimeSeriesEncoding, TimeSeriesDuplicatePolicies, Labels } from '.';
+export interface TsCreateOptions {
+    RETENTION?: number;
+    ENCODING?: TimeSeriesEncoding;
+    CHUNK_SIZE?: number;
+    DUPLICATE_POLICY?: TimeSeriesDuplicatePolicies;
+    LABELS?: Labels;
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, key: RedisArgument, options?: TsCreateOptions) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/CREATE.js

@@ -0,0 +1,15 @@
+import { pushRetentionArgument, pushEncodingArgument, pushChunkSizeArgument, pushDuplicatePolicy, pushLabelsArgument } from '.';
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, options) {
+        const args = ['TS.CREATE', key];
+        pushRetentionArgument(args, options?.RETENTION);
+        pushEncodingArgument(args, options?.ENCODING);
+        pushChunkSizeArgument(args, options?.CHUNK_SIZE);
+        pushDuplicatePolicy(args, options?.DUPLICATE_POLICY);
+        pushLabelsArgument(args, options?.LABELS);
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/CREATERULE.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+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";
+    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 FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, sourceKey: RedisArgument, destinationKey: RedisArgument, aggregationType: TimeSeriesAggregationType, bucketDuration: number, alignTimestamp?: number) => (string | Buffer)[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/CREATERULE.js

@@ -0,0 +1,34 @@
+export const TIME_SERIES_AGGREGATION_TYPE = {
+    AVG: 'AVG',
+    FIRST: 'FIRST',
+    LAST: 'LAST',
+    MIN: 'MIN',
+    MAX: '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 default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(sourceKey, destinationKey, aggregationType, bucketDuration, alignTimestamp) {
+        const args = [
+            'TS.CREATERULE',
+            sourceKey,
+            destinationKey,
+            'AGGREGATION',
+            aggregationType,
+            bucketDuration.toString()
+        ];
+        if (alignTimestamp !== undefined) {
+            args.push(alignTimestamp.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/DECRBY.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (key: import("@redis/client/dist/lib/RESP/types").RedisArgument, value: number, options?: import("./INCRBY").TsIncrByOptions | undefined) => import("@redis/client/dist/lib/RESP/types").RedisArgument[];
+    readonly transformReply: () => import("@redis/client/dist/lib/RESP/types").NumberReply<number>;
+};
+export default _default;

package/dist/lib/commands/DECRBY.js

@@ -0,0 +1,7 @@
+import INCRBY, { transformIncrByArguments } from './INCRBY';
+export default {
+    FIRST_KEY_INDEX: INCRBY.FIRST_KEY_INDEX,
+    IS_READ_ONLY: INCRBY.IS_READ_ONLY,
+    transformArguments: transformIncrByArguments.bind(undefined, 'TS.DECRBY'),
+    transformReply: INCRBY.transformReply
+};

package/dist/lib/commands/DEL.d.ts

@@ -0,0 +1,9 @@
+import { Timestamp } from '.';
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, key: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp) => RedisArgument[];
+    readonly transformReply: () => NumberReply;
+};
+export default _default;

package/dist/lib/commands/DEL.js

@@ -0,0 +1,14 @@
+import { transformTimestampArgument } from '.';
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, fromTimestamp, toTimestamp) {
+        return [
+            'TS.DEL',
+            key,
+            transformTimestampArgument(fromTimestamp),
+            transformTimestampArgument(toTimestamp)
+        ];
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/DELETERULE.d.ts

@@ -0,0 +1,8 @@
+import { RedisArgument, SimpleStringReply } from '@redis/client/dist/lib/RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, sourceKey: RedisArgument, destinationKey: RedisArgument) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

package/dist/lib/commands/DELETERULE.js

@@ -0,0 +1,12 @@
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(sourceKey, destinationKey) {
+        return [
+            'TS.DELETERULE',
+            sourceKey,
+            destinationKey
+        ];
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/GET.d.ts

@@ -0,0 +1,21 @@
+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 FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, key: RedisArgument, options?: TsGetOptions) => RedisArgument[];
+    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;

package/dist/lib/commands/GET.js

@@ -0,0 +1,25 @@
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: true,
+    transformArguments(key, options) {
+        const args = ['TS.GET', key];
+        if (options?.LATEST) {
+            args.push('LATEST');
+        }
+        return args;
+    },
+    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]
+            };
+        }
+    }
+};

package/dist/lib/commands/INCRBY.d.ts

@@ -0,0 +1,17 @@
+import { RedisArgument, NumberReply } from '@redis/client/dist/lib/RESP/types';
+import { Timestamp, Labels } from '.';
+export interface TsIncrByOptions {
+    TIMESTAMP?: Timestamp;
+    RETENTION?: number;
+    UNCOMPRESSED?: boolean;
+    CHUNK_SIZE?: number;
+    LABELS?: Labels;
+}
+export declare function transformIncrByArguments(command: RedisArgument, key: RedisArgument, value: number, options?: TsIncrByOptions): RedisArgument[];
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (key: RedisArgument, value: number, options?: TsIncrByOptions | undefined) => RedisArgument[];
+    readonly transformReply: () => NumberReply;
+};
+export default _default;

package/dist/lib/commands/INCRBY.js

@@ -0,0 +1,24 @@
+import { transformTimestampArgument, pushRetentionArgument, pushChunkSizeArgument, pushLabelsArgument } from '.';
+export function transformIncrByArguments(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;
+}
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments: transformIncrByArguments.bind(undefined, 'TS.INCRBY'),
+    transformReply: undefined
+};

package/dist/lib/commands/INFO.js

@@ -0,0 +1,77 @@
+"use strict";
+// import { TimeSeriesAggregationType, TimeSeriesDuplicatePolicies } from '.';
+// export const FIRST_KEY_INDEX = 1;
+// export const IS_READ_ONLY = true;
+// export function transformArguments(key: string): Array<string> {
+//     return ['TS.INFO', key];
+// }
+// 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 function transformReply(reply: InfoRawReply): InfoReply {
+//     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
+//         }))
+//     };
+// }

package/dist/lib/commands/INFO_DEBUG.js

@@ -0,0 +1,53 @@
+"use strict";
+// import {
+//     transformArguments as transformInfoArguments,
+//     InfoRawReply,
+//     InfoReply,
+//     transformReply as transformInfoReply
+// } from './INFO';
+// export { IS_READ_ONLY, FIRST_KEY_INDEX } from './INFO';
+// export function transformArguments(key: string): Array<string> {
+//     const args = transformInfoArguments(key);
+//     args.push('DEBUG');
+//     return args;
+// }
+// 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 function transformReply(rawReply: InfoDebugRawReply): InfoDebugReply {
+//     const reply = transformInfoReply(rawReply as unknown as InfoRawReply);
+//     (reply as InfoDebugReply).keySelfName = rawReply[25];
+//     (reply as InfoDebugReply).chunks = rawReply[27].map(chunk => ({
+//         startTimestamp: chunk[1],
+//         endTimestamp: chunk[3],
+//         samples: chunk[5],
+//         size: chunk[7],
+//         bytesPerSample: chunk[9]
+//     }));
+//     return reply as InfoDebugReply;
+// }

package/dist/lib/commands/MADD.d.ts

@@ -0,0 +1,14 @@
+import { Timestamp } from '.';
+import { ArrayReply, NumberReply, SimpleErrorReply } from '@redis/client/dist/lib/RESP/types';
+export interface TsMAddSample {
+    key: string;
+    timestamp: Timestamp;
+    value: number;
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, toAdd: Array<TsMAddSample>) => string[];
+    readonly transformReply: () => ArrayReply<NumberReply | SimpleErrorReply>;
+};
+export default _default;

package/dist/lib/commands/MADD.js

@@ -0,0 +1,13 @@
+import { transformTimestampArgument } from '.';
+export default {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(toAdd) {
+        const args = ['TS.MADD'];
+        for (const { key, timestamp, value } of toAdd) {
+            args.push(key, transformTimestampArgument(timestamp), value.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

package/dist/lib/commands/MGET.d.ts

@@ -0,0 +1,14 @@
+import { CommandArguments } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+export interface TsMGetOptions {
+    LATEST?: boolean;
+}
+export declare function pushLatestArgument(args: CommandArguments, latest?: boolean): CommandArguments;
+export declare function pushFilterArgument(args: CommandArguments, filter: RedisVariadicArgument): CommandArguments;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, filter: RedisVariadicArgument, options?: TsMGetOptions) => CommandArguments;
+    readonly transformReply: () => any;
+};
+export default _default;

package/dist/lib/commands/MGET.js

@@ -0,0 +1,22 @@
+import { pushVariadicArguments } from '@redis/client/dist/lib/commands/generic-transformers';
+export function pushLatestArgument(args, latest) {
+    if (latest) {
+        args.push('LATEST');
+    }
+    return args;
+}
+export function pushFilterArgument(args, filter) {
+    args.push('FILTER');
+    return pushVariadicArguments(args, filter);
+}
+export default {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(filter, options) {
+        const args = pushLatestArgument(['TS.MGET'], options?.LATEST);
+        return pushFilterArgument(args, filter);
+    },
+    // TODO
+    // transformSampleReply
+    transformReply: undefined
+};

package/dist/lib/commands/MGET_WITHLABELS.d.ts

@@ -0,0 +1,12 @@
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { TsMGetOptions } from './MGET';
+export interface TsMGetWithLabelsOptions extends TsMGetOptions {
+    SELECTED_LABELS?: RedisVariadicArgument;
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, filter: RedisVariadicArgument, options?: TsMGetWithLabelsOptions) => import("@redis/client/dist/lib/RESP/types").CommandArguments;
+    readonly transformReply: () => any;
+};
+export default _default;

package/dist/lib/commands/MGET_WITHLABELS.js

@@ -0,0 +1,13 @@
+import { pushLatestArgument, pushFilterArgument } from './MGET';
+import { pushWithLabelsArgument } from '.';
+export default {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(filter, options) {
+        let args = pushLatestArgument(['TS.MGET'], options?.LATEST);
+        args = pushWithLabelsArgument(args, options?.SELECTED_LABELS);
+        return pushFilterArgument(args, filter);
+    },
+    // TODO
+    transformReply: undefined
+};

package/dist/lib/commands/MRANGE.d.ts

@@ -0,0 +1,32 @@
+import { RedisArgument, CommandArguments } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { Timestamp } from '.';
+import { TsRangeOptions } from './RANGE';
+export declare const TIME_SERIES_REDUCERS: {
+    AVG: string;
+    SUM: string;
+    MIN: string;
+    MAX: string;
+    RANGE: string;
+    COUNT: string;
+    STD_P: string;
+    STD_S: string;
+    VAR_P: string;
+    VAR_S: string;
+};
+export type TimeSeriesReducers = typeof TIME_SERIES_REDUCERS[keyof typeof TIME_SERIES_REDUCERS];
+export interface TsMRangeOptions extends TsRangeOptions {
+    GROUPBY?: {
+        label: RedisArgument;
+        reducer: TimeSeriesReducers;
+    };
+}
+export declare function pushGroupByArgument(args: CommandArguments, groupBy?: TsMRangeOptions['GROUPBY']): CommandArguments;
+export declare function transformMRangeArguments(command: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsMRangeOptions): CommandArguments;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsMRangeOptions | undefined) => CommandArguments;
+    readonly transformReply: () => any;
+};
+export default _default;

package/dist/lib/commands/MRANGE.js

@@ -0,0 +1,32 @@
+import { pushRangeArguments } from './RANGE';
+import { pushFilterArgument } from './MGET';
+export const TIME_SERIES_REDUCERS = {
+    AVG: 'AVG',
+    SUM: 'SUM',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    RANGE: 'RANGE',
+    COUNT: 'COUNT',
+    STD_P: 'STD.P',
+    STD_S: 'STD.S',
+    VAR_P: 'VAR.P',
+    VAR_S: 'VAR.S'
+};
+export function pushGroupByArgument(args, groupBy) {
+    if (groupBy) {
+        args.push('GROUPBY', groupBy.label, 'REDUCE', groupBy.reducer);
+    }
+    return args;
+}
+export function transformMRangeArguments(command, fromTimestamp, toTimestamp, filter, options) {
+    let args = pushRangeArguments([command], fromTimestamp, toTimestamp, options);
+    args = pushFilterArgument(args, filter);
+    return pushGroupByArgument(args, options?.GROUPBY);
+}
+export default {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments: transformMRangeArguments.bind(undefined, 'TS.MRANGE'),
+    // TODO
+    transformReply: undefined
+};

package/dist/lib/commands/MRANGE_WITHLABELS.d.ts

@@ -0,0 +1,15 @@
+import { RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-transformers';
+import { TsMRangeOptions } from './MRANGE';
+import { Timestamp } from '.';
+export interface TsMRangeWithLabelsOptions extends TsMRangeOptions {
+    SELECTED_LABELS?: RedisVariadicArgument;
+}
+export declare function transformMRangeWithLabelsArguments(command: RedisArgument, fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsMRangeWithLabelsOptions): import("@redis/client/dist/lib/RESP/types").CommandArguments;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (fromTimestamp: Timestamp, toTimestamp: Timestamp, filter: RedisVariadicArgument, options?: TsMRangeWithLabelsOptions | undefined) => import("@redis/client/dist/lib/RESP/types").CommandArguments;
+    readonly transformReply: () => any;
+};
+export default _default;

package/dist/lib/commands/MRANGE_WITHLABELS.js

@@ -0,0 +1,17 @@
+import { pushGroupByArgument } from './MRANGE';
+import { pushWithLabelsArgument } from '.';
+import { pushFilterArgument } from './MGET';
+import { pushRangeArguments } from './RANGE';
+export function transformMRangeWithLabelsArguments(command, fromTimestamp, toTimestamp, filter, options) {
+    let args = pushRangeArguments([command], fromTimestamp, toTimestamp, options);
+    args = pushWithLabelsArgument(args, options?.SELECTED_LABELS);
+    args = pushFilterArgument(args, filter);
+    return pushGroupByArgument(args, options?.GROUPBY);
+}
+export default {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments: transformMRangeWithLabelsArguments.bind(undefined, 'TS.MRANGE'),
+    // TODO
+    transformReply: undefined
+};