@storehouse/redis-om - v1.0.0
    Preparing search index...

    Class RedisOMManager<M, F, S, RESP, TYPE_MAPPING>

    Manager class for Redis-OM (Object Mapping) integration with Storehouse. Provides connection management, model registration, and health checking for Redis databases.

    This manager wraps the Redis client and Redis-OM repositories, offering a unified interface for working with Redis as a document store using the Redis-OM library.

    const manager = new RedisOMManager({
      name: 'redis-main',
      config: {
        models: [userSchema, productSchema],
        options: {
          url: 'redis://localhost:6379',
          database: 0
        }
      }
    });

    await manager.connect();
    await manager.createIndexes();

    const userRepo = manager.getModel('User');
    const users = await userRepo.search().return.all();

    Type Parameters

    • M extends RedisModules = RedisDefaultModules

      Redis modules type, defaults to RedisDefaultModules

    • F extends RedisFunctions = RedisFunctions

      Redis functions type, defaults to RedisFunctions

    • S extends RedisScripts = RedisScripts

      Redis scripts type, defaults to RedisScripts

    • RESP extends RespVersions = 2

      Redis RESP protocol version, defaults to 2

    • TYPE_MAPPING extends TypeMapping = TypeMapping

      Redis type mapping, defaults to TypeMapping

    Implements

    • IManager
    Index

    Constructors

    constructor

    Properties

    name type

    Methods

    addModel close closeConnection connect createIndexes dropIndexes getConnection getModel healthCheck isConnected

    Constructors

    • Creates a new RedisOMManager instance.

      Type Parameters

      • M extends RedisModules = {
            bf: {
                add: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                ADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                card: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                CARD: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                exists: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                EXISTS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                info: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"Capacity">,
                                NumberReply<number>,
                                SimpleStringReply<"Size">,
                                NumberReply<number>,
                                SimpleStringReply<"Number of filters">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => BfInfoReplyMap;
                        "3": () => BfInfoReplyMap;
                    };
                };
                INFO: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"Capacity">,
                                NumberReply<number>,
                                SimpleStringReply<"Size">,
                                NumberReply<number>,
                                SimpleStringReply<"Number of filters">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => BfInfoReplyMap;
                        "3": () => BfInfoReplyMap;
                    };
                };
                insert: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                        options?: BfInsertOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                INSERT: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                        options?: BfInsertOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                loadChunk: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                        chunk: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                LOADCHUNK: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                        chunk: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                mAdd: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                MADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                mExists: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                MEXISTS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                reserve: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        errorRate: number,
                        capacity: number,
                        options?: BfReserveOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                RESERVE: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        errorRate: number,
                        capacity: number,
                        options?: BfReserveOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                scanDump: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: [NumberReply<number>, BlobStringReply<string>],
                    ) => { chunk: BlobStringReply<string>; iterator: NumberReply<number> };
                };
                SCANDUMP: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: [NumberReply<number>, BlobStringReply<string>],
                    ) => { chunk: BlobStringReply<string>; iterator: NumberReply<number> };
                };
            };
            cf: {
                add: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                ADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                addNX: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                ADDNX: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                count: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                COUNT: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                del: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                DEL: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                exists: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                EXISTS: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        item: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: NumberReply<0 | 1>) => boolean;
                        "3": () => BooleanReply<boolean>;
                    };
                };
                info: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"Size">,
                                NumberReply<number>,
                                SimpleStringReply<"Number of buckets">,
                                NumberReply<number>,
                                SimpleStringReply<"Number of filters">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => CfInfoReplyMap;
                        "3": () => CfInfoReplyMap;
                    };
                };
                INFO: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"Size">,
                                NumberReply<number>,
                                SimpleStringReply<"Number of buckets">,
                                NumberReply<number>,
                                SimpleStringReply<"Number of filters">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => CfInfoReplyMap;
                        "3": () => CfInfoReplyMap;
                    };
                };
                insert: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                        options?: CfInsertOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                INSERT: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                        options?: CfInsertOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                insertNX: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                        options?: CfInsertOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                INSERTNX: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                        options?: CfInsertOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                loadChunk: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                        chunk: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                LOADCHUNK: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                        chunk: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                reserve: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        capacity: number,
                        options?: CfReserveOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                RESERVE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        capacity: number,
                        options?: CfReserveOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                scanDump: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: [NumberReply<number>, NullReply | BlobStringReply<string>],
                    ) => {
                        chunk: NullReply | BlobStringReply<string>;
                        iterator: NumberReply<number>;
                    };
                };
                SCANDUMP: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        iterator: number,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: [NumberReply<number>, NullReply | BlobStringReply<string>],
                    ) => {
                        chunk: NullReply | BlobStringReply<string>;
                        iterator: NumberReply<number>;
                    };
                };
            };
            cms: {
                incrBy: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: BfIncrByItem | BfIncrByItem[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                INCRBY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: BfIncrByItem | BfIncrByItem[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                info: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"width">,
                                NumberReply<number>,
                                SimpleStringReply<"depth">,
                                NumberReply<number>,
                                SimpleStringReply<"count">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => CmsInfoReply;
                        "3": () => CmsInfoReply;
                    };
                };
                INFO: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"width">,
                                NumberReply<number>,
                                SimpleStringReply<"depth">,
                                NumberReply<number>,
                                SimpleStringReply<"count">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => CmsInfoReply;
                        "3": () => CmsInfoReply;
                    };
                };
                initByDim: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        width: number,
                        depth: number,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                INITBYDIM: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        width: number,
                        depth: number,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                initByProb: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        error: number,
                        probability: number,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                INITBYPROB: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        error: number,
                        probability: number,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                merge: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        destination: RedisArgument,
                        source: BfMergeSketches,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                MERGE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        destination: RedisArgument,
                        source: BfMergeSketches,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                query: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                QUERY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
            };
            ft: {
                _list: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (this: void, parser: CommandParser) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                _LIST: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (this: void, parser: CommandParser) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                aggregate: {
                    IS_READ_ONLY: false;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtAggregateOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            rawReply: [
                                total: UnwrapReply<NumberReply<number>>,
                                ...results: ArrayReply<BlobStringReply<string>>[],
                            ],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => AggregateReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                AGGREGATE: {
                    IS_READ_ONLY: false;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtAggregateOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            rawReply: [
                                total: UnwrapReply<NumberReply<number>>,
                                ...results: ArrayReply<BlobStringReply<string>>[],
                            ],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => AggregateReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                AGGREGATE_WITHCURSOR: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtAggregateWithCursorOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                result: [
                                    total: UnwrapReply<NumberReply<number>>,
                                    ...results: ArrayReply<BlobStringReply<string>>[],
                                ],
                                cursor: NumberReply<number>,
                            ],
                        ) => AggregateWithCursorReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                aggregateWithCursor: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtAggregateWithCursorOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                result: [
                                    total: UnwrapReply<NumberReply<number>>,
                                    ...results: ArrayReply<BlobStringReply<string>>[],
                                ],
                                cursor: NumberReply<number>,
                            ],
                        ) => AggregateWithCursorReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                aliasAdd: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        alias: RedisArgument,
                        index: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                ALIASADD: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        alias: RedisArgument,
                        index: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                aliasDel: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        alias: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                ALIASDEL: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        alias: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                aliasUpdate: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        alias: RedisArgument,
                        index: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                ALIASUPDATE: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        alias: RedisArgument,
                        index: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                alter: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        schema: RediSearchSchema,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                ALTER: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        schema: RediSearchSchema,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CONFIG_GET: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (this: void, parser: CommandParser, option: string) => void;
                    transformReply: (
                        this: void,
                        reply: TuplesReply<
                            [BlobStringReply<string>, NullReply | BlobStringReply<string>],
                        >[],
                    ) => Record<string, NullReply | BlobStringReply>;
                };
                CONFIG_SET: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        property: Buffer<ArrayBufferLike> | string & {} | "a" | "b",
                        value: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                configGet: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (this: void, parser: CommandParser, option: string) => void;
                    transformReply: (
                        this: void,
                        reply: TuplesReply<
                            [BlobStringReply<string>, NullReply | BlobStringReply<string>],
                        >[],
                    ) => Record<string, NullReply | BlobStringReply>;
                };
                configSet: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        property: Buffer<ArrayBufferLike> | string & {} | "a" | "b",
                        value: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                create: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        schema: RediSearchSchema,
                        options?: CreateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CREATE: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        schema: RediSearchSchema,
                        options?: CreateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CURSOR_DEL: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        cursorId: UnwrapReply<NumberReply<number>>,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CURSOR_READ: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        cursor: UnwrapReply<NumberReply<number>>,
                        options?: FtCursorReadOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                result: [
                                    total: UnwrapReply<NumberReply<number>>,
                                    ...results: ArrayReply<BlobStringReply<string>>[],
                                ],
                                cursor: NumberReply<number>,
                            ],
                        ) => AggregateWithCursorReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                cursorDel: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        cursorId: UnwrapReply<NumberReply<number>>,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                cursorRead: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        cursor: UnwrapReply<NumberReply<number>>,
                        options?: FtCursorReadOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                result: [
                                    total: UnwrapReply<NumberReply<number>>,
                                    ...results: ArrayReply<BlobStringReply<string>>[],
                                ],
                                cursor: NumberReply<number>,
                            ],
                        ) => AggregateWithCursorReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                dictAdd: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        dictionary: RedisArgument,
                        term: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                DICTADD: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        dictionary: RedisArgument,
                        term: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                dictDel: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        dictionary: RedisArgument,
                        term: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                DICTDEL: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        dictionary: RedisArgument,
                        term: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                dictDump: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        dictionary: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                DICTDUMP: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        dictionary: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                dropIndex: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        options?: FtDropIndexOptions,
                    ) => void;
                    transformReply: {
                        "2": () => SimpleStringReply<"OK">;
                        "3": () => NumberReply<number>;
                    };
                };
                DROPINDEX: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        options?: FtDropIndexOptions,
                    ) => void;
                    transformReply: {
                        "2": () => SimpleStringReply<"OK">;
                        "3": () => NumberReply<number>;
                    };
                };
                explain: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtExplainOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<string>;
                };
                EXPLAIN: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtExplainOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<string>;
                };
                explainCli: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtExplainCLIOptions,
                    ) => void;
                    transformReply: () => ArrayReply<BlobStringReply<string>>;
                };
                EXPLAINCLI: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtExplainCLIOptions,
                    ) => void;
                    transformReply: () => ArrayReply<BlobStringReply<string>>;
                };
                hybrid: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        options?: FtHybridOptions,
                    ) => void;
                    transformReply: { "2": (reply: any) => any; "3": () => ReplyUnion };
                    unstableResp3: true;
                };
                HYBRID: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        options?: FtHybridOptions,
                    ) => void;
                    transformReply: { "2": (reply: any) => any; "3": () => ReplyUnion };
                    unstableResp3: true;
                };
                info: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: any[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => InfoReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                INFO: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: any[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => InfoReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                profileAggregate: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: string,
                        query: string,
                        options?: ProfileOptions & FtAggregateOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                [
                                    total: UnwrapReply<NumberReply<number>>,
                                    ...results: ArrayReply<BlobStringReply<string>>[],
                                ],
                                ArrayReply<ReplyUnion>,
                            ],
                        ) => ProfileReplyResp2;
                        "3": (reply: ReplyUnion) => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                PROFILEAGGREGATE: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: string,
                        query: string,
                        options?: ProfileOptions & FtAggregateOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                [
                                    total: UnwrapReply<NumberReply<number>>,
                                    ...results: ArrayReply<BlobStringReply<string>>[],
                                ],
                                ArrayReply<ReplyUnion>,
                            ],
                        ) => ProfileReplyResp2;
                        "3": (reply: ReplyUnion) => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                profileSearch: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: ProfileOptions & FtSearchOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [SearchRawReply, ArrayReply<ReplyUnion>],
                        ) => ProfileReplyResp2;
                        "3": (reply: ReplyUnion) => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                PROFILESEARCH: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: ProfileOptions & FtSearchOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [SearchRawReply, ArrayReply<ReplyUnion>],
                        ) => ProfileReplyResp2;
                        "3": (reply: ReplyUnion) => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                search: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtSearchOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: SearchRawReply) => SearchReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                SEARCH: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtSearchOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: SearchRawReply) => SearchReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                SEARCH_NOCONTENT: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtSearchOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: SearchRawReply) => SearchNoContentReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                searchNoContent: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtSearchOptions,
                    ) => void;
                    transformReply: {
                        "2": (reply: SearchRawReply) => SearchNoContentReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                spellCheck: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtSpellCheckOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            rawReply: [
                                _: string,
                                term: string,
                                suggestions: [score: string, suggestion: string][],
                            ][],
                        ) => {
                            suggestions: { score: number; suggestion: string }[];
                            term: string;
                        }[];
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                SPELLCHECK: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        query: RedisArgument,
                        options?: FtSpellCheckOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            rawReply: [
                                _: string,
                                term: string,
                                suggestions: [score: string, suggestion: string][],
                            ][],
                        ) => {
                            suggestions: { score: number; suggestion: string }[];
                            term: string;
                        }[];
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                sugAdd: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        string: RedisArgument,
                        score: number,
                        options?: FtSugAddOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                SUGADD: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        string: RedisArgument,
                        score: number,
                        options?: FtSugAddOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                sugDel: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        string: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<0 | 1>;
                };
                SUGDEL: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        string: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<0 | 1>;
                };
                sugGet: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: () => NullReply | ArrayReply<BlobStringReply<string>>;
                };
                SUGGET: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: () => NullReply | ArrayReply<BlobStringReply<string>>;
                };
                SUGGET_WITHPAYLOADS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: NullReply | BlobStringReply<string>[],
                    ) =>
                        | {
                            payload: BlobStringReply<string>;
                            suggestion: BlobStringReply<string>;
                        }[]
                        | null;
                };
                SUGGET_WITHSCORES: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: NullReply | BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) =>
                            | {
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                        "3": (
                            reply: (BlobStringReply<string> | DoubleReply<number>)[],
                        ) =>
                            | {
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                    };
                };
                SUGGET_WITHSCORES_WITHPAYLOADS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: NullReply | BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) =>
                            | {
                                payload: BlobStringReply<string>;
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                        "3": (
                            reply: NullReply | (BlobStringReply<string> | DoubleReply<number>)[],
                        ) =>
                            | {
                                payload: BlobStringReply<string>;
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                    };
                };
                sugGetWithPayloads: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: NullReply | BlobStringReply<string>[],
                    ) =>
                        | {
                            payload: BlobStringReply<string>;
                            suggestion: BlobStringReply<string>;
                        }[]
                        | null;
                };
                sugGetWithScores: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: NullReply | BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) =>
                            | {
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                        "3": (
                            reply: (BlobStringReply<string> | DoubleReply<number>)[],
                        ) =>
                            | {
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                    };
                };
                sugGetWithScoresWithPayloads: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        prefix: RedisArgument,
                        options?: FtSugGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: NullReply | BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) =>
                            | {
                                payload: BlobStringReply<string>;
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                        "3": (
                            reply: NullReply | (BlobStringReply<string> | DoubleReply<number>)[],
                        ) =>
                            | {
                                payload: BlobStringReply<string>;
                                score: DoubleReply<number>;
                                suggestion: BlobStringReply<string>;
                            }[]
                            | null;
                    };
                };
                sugLen: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                SUGLEN: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                synDump: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: (
                                BlobStringReply<string>
                                | ArrayReply<BlobStringReply<string>>
                            )[],
                        ) => Record<string, ArrayReply>;
                        "3": () => MapReply<
                            BlobStringReply<string>,
                            ArrayReply<BlobStringReply<string>>,
                        >;
                    };
                };
                SYNDUMP: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: (
                                BlobStringReply<string>
                                | ArrayReply<BlobStringReply<string>>
                            )[],
                        ) => Record<string, ArrayReply>;
                        "3": () => MapReply<
                            BlobStringReply<string>,
                            ArrayReply<BlobStringReply<string>>,
                        >;
                    };
                };
                synUpdate: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        groupId: RedisArgument,
                        terms: RedisVariadicArgument,
                        options?: FtSynUpdateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                SYNUPDATE: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        groupId: RedisArgument,
                        terms: RedisVariadicArgument,
                        options?: FtSynUpdateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                tagVals: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        fieldName: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                TAGVALS: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        index: RedisArgument,
                        fieldName: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
            };
            json: {
                arrAppend: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        json: RedisJSON,
                        ...jsons: RedisJSON[],
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                ARRAPPEND: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        json: RedisJSON,
                        ...jsons: RedisJSON[],
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                arrIndex: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        json: RedisJSON,
                        options?: JsonArrIndexOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                ARRINDEX: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        json: RedisJSON,
                        options?: JsonArrIndexOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                arrInsert: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        index: number,
                        json: RedisJSON,
                        ...jsons: RedisJSON[],
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                ARRINSERT: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        index: number,
                        json: RedisJSON,
                        ...jsons: RedisJSON[],
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                arrLen: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonArrLenOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                ARRLEN: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonArrLenOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                arrPop: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: RedisArrPopOptions,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply:
                            | NullReply
                            | BlobStringReply<string>
                            | ArrayReply<NullReply | BlobStringReply<string>>,
                    ) =>
                        | string
                        | number
                        | boolean
                        | Date
                        | NullReply
                        | (RedisJSON | NullReply)[]
                        | { [key: string]: RedisJSON; [key: number]: RedisJSON }
                        | null;
                };
                ARRPOP: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: RedisArrPopOptions,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply:
                            | NullReply
                            | BlobStringReply<string>
                            | ArrayReply<NullReply | BlobStringReply<string>>,
                    ) =>
                        | string
                        | number
                        | boolean
                        | Date
                        | NullReply
                        | { [key: string]: RedisJSON; [key: number]: RedisJSON }
                        | (RedisJSON | NullReply)[]
                        | null;
                };
                arrTrim: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        start: number,
                        stop: number,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                ARRTRIM: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        start: number,
                        stop: number,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                clear: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonClearOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                CLEAR: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonClearOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                DEBUG_MEMORY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonDebugMemoryOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                debugMemory: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonDebugMemoryOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                del: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonDelOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                DEL: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonDelOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                forget: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonForgetOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                FORGET: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonForgetOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                get: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonGetOptions,
                    ) => void;
                    transformReply: (
                        json: NullReply | BlobStringReply<string>,
                    ) => RedisJSON | NullReply;
                };
                GET: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonGetOptions,
                    ) => void;
                    transformReply: (
                        json: NullReply | BlobStringReply<string>,
                    ) => RedisJSON | NullReply;
                };
                merge: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        value: RedisJSON,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                MERGE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        value: RedisJSON,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                mGet: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        keys: RedisArgument[],
                        path: RedisArgument,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: (NullReply | BlobStringReply<string>)[],
                    ) => (RedisJSON | NullReply)[];
                };
                MGET: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        keys: RedisArgument[],
                        path: RedisArgument,
                    ) => void;
                    transformReply: (
                        this: void,
                        reply: (NullReply | BlobStringReply<string>)[],
                    ) => (RedisJSON | NullReply)[];
                };
                mSet: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        items: JsonMSetItem[],
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                MSET: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        items: JsonMSetItem[],
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                numIncrBy: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        by: number,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: UnwrapReply<BlobStringReply<string>>,
                        ) => number | (number | null)[];
                        "3": () => ArrayReply<
                            NullReply
                            | NumberReply<number>
                            | DoubleReply<number>,
                        >;
                    };
                };
                NUMINCRBY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        by: number,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: UnwrapReply<BlobStringReply<string>>,
                        ) => number | (number | null)[];
                        "3": () => ArrayReply<
                            NullReply
                            | NumberReply<number>
                            | DoubleReply<number>,
                        >;
                    };
                };
                numMultBy: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        by: number,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: UnwrapReply<BlobStringReply<string>>,
                        ) => number | (number | null)[];
                        "3": () => ArrayReply<
                            NullReply
                            | NumberReply<number>
                            | DoubleReply<number>,
                        >;
                    };
                };
                NUMMULTBY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        by: number,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: UnwrapReply<BlobStringReply<string>>,
                        ) => number | (number | null)[];
                        "3": () => ArrayReply<
                            NullReply
                            | NumberReply<number>
                            | DoubleReply<number>,
                        >;
                    };
                };
                objKeys: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonObjKeysOptions,
                    ) => void;
                    transformReply: () => | ArrayReply<BlobStringReply<string>>
                    | ArrayReply<NullReply | ArrayReply<BlobStringReply<string>>>;
                };
                OBJKEYS: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonObjKeysOptions,
                    ) => void;
                    transformReply: () => | ArrayReply<BlobStringReply<string>>
                    | ArrayReply<NullReply | ArrayReply<BlobStringReply<string>>>;
                };
                objLen: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonObjLenOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                OBJLEN: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonObjLenOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                set: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        json: RedisJSON,
                        options?: JsonSetOptions,
                    ) => void;
                    transformReply: () => NullReply | SimpleStringReply<"OK">;
                };
                SET: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                        json: RedisJSON,
                        options?: JsonSetOptions,
                    ) => void;
                    transformReply: () => NullReply | SimpleStringReply<"OK">;
                };
                strAppend: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        append: string,
                        options?: JsonStrAppendOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                STRAPPEND: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        append: string,
                        options?: JsonStrAppendOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                strLen: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonStrLenOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                STRLEN: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonStrLenOptions,
                    ) => void;
                    transformReply: () => | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                toggle: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                    ) => void;
                    transformReply: () => | NullReply
                    | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                TOGGLE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        path: RedisArgument,
                    ) => void;
                    transformReply: () => | NullReply
                    | NumberReply<number>
                    | ArrayReply<NullReply | NumberReply<number>>;
                };
                type: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonTypeOptions,
                    ) => void;
                    transformReply: {
                        "2": () => | NullReply
                        | BlobStringReply<string>
                        | ArrayReply<NullReply | BlobStringReply<string>>;
                        "3": (
                            reply: (
                                | NullReply
                                | BlobStringReply<string>
                                | ArrayReply<NullReply | BlobStringReply<string>>
                            )[],
                        ) =>
                            | NullReply
                            | BlobStringReply<string>
                            | ArrayReply<NullReply | BlobStringReply<string>>;
                    };
                };
                TYPE: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: JsonTypeOptions,
                    ) => void;
                    transformReply: {
                        "2": () => | NullReply
                        | BlobStringReply<string>
                        | ArrayReply<NullReply | BlobStringReply<string>>;
                        "3": (
                            reply: (
                                | NullReply
                                | BlobStringReply<string>
                                | ArrayReply<NullReply | BlobStringReply<string>>
                            )[],
                        ) =>
                            | NullReply
                            | BlobStringReply<string>
                            | ArrayReply<NullReply | BlobStringReply<string>>;
                    };
                };
            };
            tDigest: {
                add: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                ADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                byRank: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        ranks: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                BYRANK: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        ranks: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                byRevRank: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        ranks: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                BYREVRANK: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        ranks: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                cdf: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                CDF: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                create: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TDigestCreateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CREATE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TDigestCreateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                info: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"Compression">,
                                NumberReply<number>,
                                SimpleStringReply<"Capacity">,
                                NumberReply<number>,
                                SimpleStringReply<"Merged nodes">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => TdInfoReplyMap;
                        "3": () => TdInfoReplyMap;
                    };
                };
                INFO: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                SimpleStringReply<"Compression">,
                                NumberReply<number>,
                                SimpleStringReply<"Capacity">,
                                NumberReply<number>,
                                SimpleStringReply<"Merged nodes">,
                                NumberReply<number>,
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => TdInfoReplyMap;
                        "3": () => TdInfoReplyMap;
                    };
                };
                max: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>,
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>;
                        "3": () => DoubleReply<number>;
                    };
                };
                MAX: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>,
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>;
                        "3": () => DoubleReply<number>;
                    };
                };
                merge: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        destination: RedisArgument,
                        source: RedisVariadicArgument,
                        options?: TDigestMergeOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                MERGE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        destination: RedisArgument,
                        source: RedisVariadicArgument,
                        options?: TDigestMergeOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                min: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>,
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>;
                        "3": () => DoubleReply<number>;
                    };
                };
                MIN: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>,
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>;
                        "3": () => DoubleReply<number>;
                    };
                };
                quantile: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        quantiles: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                QUANTILE: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        quantiles: number[],
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>[],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>[];
                        "3": () => ArrayReply<DoubleReply<number>>;
                    };
                };
                rank: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                RANK: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                reset: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                RESET: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                revRank: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                REVRANK: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        values: number[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                TRIMMED_MEAN: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        lowCutPercentile: number,
                        highCutPercentile: number,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>,
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>;
                        "3": () => DoubleReply<number>;
                    };
                };
                trimmedMean: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        lowCutPercentile: number,
                        highCutPercentile: number,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: BlobStringReply<string>,
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => DoubleReply<number>;
                        "3": () => DoubleReply<number>;
                    };
                };
            };
            topK: {
                add: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => ArrayReply<BlobStringReply<string>>;
                };
                ADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => ArrayReply<BlobStringReply<string>>;
                };
                count: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                COUNT: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number>>;
                };
                incrBy: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: TopKIncrByItem | TopKIncrByItem[],
                    ) => void;
                    transformReply: () => ArrayReply<NullReply | SimpleStringReply<string>>;
                };
                INCRBY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: TopKIncrByItem | TopKIncrByItem[],
                    ) => void;
                    transformReply: () => ArrayReply<NullReply | SimpleStringReply<string>>;
                };
                info: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                SimpleStringReply<"k">,
                                NumberReply<number>,
                                SimpleStringReply<"width">,
                                NumberReply<number>,
                                SimpleStringReply<"depth">,
                                NumberReply<number>,
                                SimpleStringReply<"decay">,
                                BlobStringReply<string>,
                            ],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => TopKInfoReplyMap;
                        "3": () => TopKInfoReplyMap;
                    };
                };
                INFO: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: {
                        "2": (
                            reply: [
                                SimpleStringReply<"k">,
                                NumberReply<number>,
                                SimpleStringReply<"width">,
                                NumberReply<number>,
                                SimpleStringReply<"depth">,
                                NumberReply<number>,
                                SimpleStringReply<"decay">,
                                BlobStringReply<string>,
                            ],
                            preserve?: any,
                            typeMapping?: TypeMapping,
                        ) => TopKInfoReplyMap;
                        "3": () => TopKInfoReplyMap;
                    };
                };
                list: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => ArrayReply<BlobStringReply<string>>;
                };
                LIST: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: () => ArrayReply<BlobStringReply<string>>;
                };
                LIST_WITHCOUNT: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: (
                        this: void,
                        rawReply: (BlobStringReply<string> | NumberReply<number>)[],
                    ) => { count: NumberReply<number>; item: BlobStringReply<string> }[];
                };
                listWithCount: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                    ) => void;
                    transformReply: (
                        this: void,
                        rawReply: (BlobStringReply<string> | NumberReply<number>)[],
                    ) => { count: NumberReply<number>; item: BlobStringReply<string> }[];
                };
                query: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                QUERY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        items: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": (reply: ArrayReply<NumberReply<0 | 1>>) => boolean[];
                        "3": () => ArrayReply<BooleanReply<boolean>>;
                    };
                };
                reserve: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        topK: number,
                        options?: TopKReserveOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                RESERVE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        topK: number,
                        options?: TopKReserveOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
            };
            ts: {
                add: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        timestamp: Timestamp,
                        value: number,
                        options?: TsAddOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                ADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        timestamp: Timestamp,
                        value: number,
                        options?: TsAddOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                alter: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TsAlterOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                ALTER: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TsAlterOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                create: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TsCreateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CREATE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TsCreateOptions,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                createRule: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        sourceKey: RedisArgument,
                        destinationKey: RedisArgument,
                        aggregationType: TimeSeriesAggregationType,
                        bucketDuration: number,
                        alignTimestamp?: number,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                CREATERULE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        sourceKey: RedisArgument,
                        destinationKey: RedisArgument,
                        aggregationType: TimeSeriesAggregationType,
                        bucketDuration: number,
                        alignTimestamp?: number,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                decrBy: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        value: number,
                        options?: TsIncrByOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                DECRBY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        value: number,
                        options?: TsIncrByOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                del: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                DEL: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                deleteRule: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        sourceKey: RedisArgument,
                        destinationKey: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                DELETERULE: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        sourceKey: RedisArgument,
                        destinationKey: RedisArgument,
                    ) => void;
                    transformReply: () => SimpleStringReply<"OK">;
                };
                get: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TsGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: UnwrapReply<
                                | RespType<42, [], never, []>
                                | RespType<
                                    42,
                                    [NumberReply<number>, BlobStringReply<string>],
                                    never,
                                    [NumberReply<number>, BlobStringReply<string>],
                                >,
                            >,
                        ) => { timestamp: NumberReply<number>; value: number } | null;
                        "3": (
                            this: void,
                            reply: UnwrapReply<TsGetReply>,
                        ) =>
                            | { timestamp: NumberReply<number>; value: DoubleReply<number> }
                            | null;
                    };
                };
                GET: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        options?: TsGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: UnwrapReply<
                                | RespType<42, [], never, []>
                                | RespType<
                                    42,
                                    [NumberReply<number>, BlobStringReply<string>],
                                    never,
                                    [NumberReply<number>, BlobStringReply<string>],
                                >,
                            >,
                        ) => { timestamp: NumberReply<number>; value: number } | null;
                        "3": (
                            this: void,
                            reply: UnwrapReply<TsGetReply>,
                        ) =>
                            | { timestamp: NumberReply<number>; value: DoubleReply<number> }
                            | null;
                    };
                };
                incrBy: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        value: number,
                        options?: TsIncrByOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                INCRBY: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        value: number,
                        options?: TsIncrByOptions,
                    ) => void;
                    transformReply: () => NumberReply<number>;
                };
                info: {
                    IS_READ_ONLY: true;
                    parseCommand: (this: void, parser: CommandParser, key: string) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: InfoRawReply,
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => InfoReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                INFO: {
                    IS_READ_ONLY: true;
                    parseCommand: (this: void, parser: CommandParser, key: string) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: InfoRawReply,
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => InfoReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                INFO_DEBUG: {
                    IS_READ_ONLY: true;
                    parseCommand: (this: void, parser: CommandParser, key: string) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                ...InfoRawReplyTypes[],
                                "keySelfName",
                                BlobStringReply<string>,
                                "Chunks",
                                [
                                    "startTimestamp",
                                    NumberReply<number>,
                                    "endTimestamp",
                                    NumberReply<number>,
                                    "samples",
                                    NumberReply<number>,
                                    "size",
                                    NumberReply<number>,
                                    "bytesPerSample",
                                    SimpleStringReply<string>,
                                ][],
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => InfoDebugReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                infoDebug: {
                    IS_READ_ONLY: true;
                    parseCommand: (this: void, parser: CommandParser, key: string) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: [
                                ...InfoRawReplyTypes[],
                                "keySelfName",
                                BlobStringReply<string>,
                                "Chunks",
                                [
                                    "startTimestamp",
                                    NumberReply<number>,
                                    "endTimestamp",
                                    NumberReply<number>,
                                    "samples",
                                    NumberReply<number>,
                                    "size",
                                    NumberReply<number>,
                                    "bytesPerSample",
                                    SimpleStringReply<string>,
                                ][],
                            ],
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => InfoDebugReply;
                        "3": () => ReplyUnion;
                    };
                    unstableResp3: true;
                };
                mAdd: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        toAdd: TsMAddSample[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number> | SimpleErrorReply>;
                };
                MADD: {
                    IS_READ_ONLY: false;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        toAdd: TsMAddSample[],
                    ) => void;
                    transformReply: () => ArrayReply<NumberReply<number> | SimpleErrorReply>;
                };
                mGet: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                        options?: TsMGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: MGetRawReply2,
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { sample: { timestamp: NumberReply<number>; value: number } },
                        >;
                        "3": (
                            this: void,
                            reply: MGetRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                sample: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                };
                            },
                        >;
                    };
                };
                MGET: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                        options?: TsMGetOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: MGetRawReply2,
                            _: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { sample: { timestamp: NumberReply<number>; value: number } },
                        >;
                        "3": (
                            this: void,
                            reply: MGetRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                sample: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                };
                            },
                        >;
                    };
                };
                MGET_SELECTED_LABELS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                        selectedLabels: RedisVariadicArgument,
                        options?: TsMGetOptions,
                    ) => void;
                    transformReply: {
                        "2"(
                            this: void,
                            reply: MGetLabelsRawReply2<NullReply | BlobStringReply<string>>,
                            _: any,
                            typeMapping?: TypeMapping,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                sample: { timestamp: NumberReply<number>; value: number };
                            },
                        >;
                        "3"(
                            this: void,
                            reply: MGetLabelsRawReply3<NullReply | BlobStringReply<string>>,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                sample: { timestamp: NumberReply<number>; value: DoubleReply<number> };
                            },
                        >;
                    };
                };
                MGET_WITHLABELS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                        options?: TsMGetWithLabelsOptions,
                    ) => void;
                    transformReply: {
                        "2"(
                            this: void,
                            reply: MGetLabelsRawReply2<BlobStringReply<string>>,
                            _: any,
                            typeMapping?: TypeMapping,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                sample: { timestamp: NumberReply<number>; value: number };
                            },
                        >;
                        "3"(
                            this: void,
                            reply: MGetLabelsRawReply3<BlobStringReply<string>>,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                sample: { timestamp: NumberReply<number>; value: DoubleReply<number> };
                            },
                        >;
                    };
                };
                mGetSelectedLabels: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                        selectedLabels: RedisVariadicArgument,
                        options?: TsMGetOptions,
                    ) => void;
                    transformReply: {
                        "2"(
                            this: void,
                            reply: MGetLabelsRawReply2<NullReply | BlobStringReply<string>>,
                            _: any,
                            typeMapping?: TypeMapping,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                sample: { timestamp: NumberReply<number>; value: number };
                            },
                        >;
                        "3"(
                            this: void,
                            reply: MGetLabelsRawReply3<NullReply | BlobStringReply<string>>,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                sample: { timestamp: NumberReply<number>; value: DoubleReply<number> };
                            },
                        >;
                    };
                };
                mGetWithLabels: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                        options?: TsMGetWithLabelsOptions,
                    ) => void;
                    transformReply: {
                        "2"(
                            this: void,
                            reply: MGetLabelsRawReply2<BlobStringReply<string>>,
                            _: any,
                            typeMapping?: TypeMapping,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                sample: { timestamp: NumberReply<number>; value: number };
                            },
                        >;
                        "3"(
                            this: void,
                            reply: MGetLabelsRawReply3<BlobStringReply<string>>,
                        ): MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                sample: { timestamp: NumberReply<number>; value: DoubleReply<number> };
                            },
                        >;
                    };
                };
                mRange: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: number }[],
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: DoubleReply<number> }[],
                        >;
                    };
                };
                MRANGE: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: number }[],
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: DoubleReply<number> }[],
                        >;
                    };
                };
                MRANGE_GROUPBY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { samples: { timestamp: NumberReply<number>; value: number }[] },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                MRANGE_SELECTED_LABELS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: never;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                MRANGE_SELECTED_LABELS_GROUPBY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                MRANGE_WITHLABELS: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: Record<string, BlobStringReply>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                MRANGE_WITHLABELS_GROUPBY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                                sources: string[] | Buffer<ArrayBufferLike>[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRangeGroupBy: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { samples: { timestamp: NumberReply<number>; value: number }[] },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRangeSelectedLabels: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: never;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                mRangeSelectedLabelsGroupBy: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRangeWithLabels: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: Record<string, BlobStringReply>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                mRangeWithLabelsGroupBy: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                                sources: string[] | Buffer<ArrayBufferLike>[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRevRange: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: number }[],
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: DoubleReply<number> }[],
                        >;
                    };
                };
                MREVRANGE: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: number }[],
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { timestamp: NumberReply<number>; value: DoubleReply<number> }[],
                        >;
                    };
                };
                MREVRANGE_GROUPBY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { samples: { timestamp: NumberReply<number>; value: number }[] },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                MREVRANGE_SELECTED_LABELS: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: never;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                MREVRANGE_SELECTED_LABELS_GROUPBY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                MREVRANGE_WITHLABELS: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: Record<string, BlobStringReply>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                MREVRANGE_WITHLABELS_GROUPBY: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                                sources: string[] | Buffer<ArrayBufferLike>[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRevRangeGroupBy: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            { samples: { timestamp: NumberReply<number>; value: number }[] },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRevRangeSelectedLabels: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: never;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                mRevRangeSelectedLabelsGroupBy: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        selectedLabels: RedisVariadicArgument,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeSelectedLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<
                                    BlobStringReply<string>,
                                    NullReply | BlobStringReply<string>,
                                >;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                mRevRangeWithLabels: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: Record<string, BlobStringReply>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                            },
                        >;
                    };
                };
                mRevRangeWithLabelsGroupBy: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        parser: CommandParser,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        filter: RedisVariadicArgument,
                        groupBy: TsMRangeGroupBy,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply2,
                            _?: any,
                            typeMapping?: TypeMapping,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: { timestamp: NumberReply<number>; value: number }[];
                                sources: string[] | Buffer<ArrayBufferLike>[];
                            },
                        >;
                        "3": (
                            this: void,
                            reply: TsMRangeWithLabelsGroupByRawReply3,
                        ) => MapReply<
                            BlobStringReply<string>,
                            {
                                labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                                samples: {
                                    timestamp: NumberReply<number>;
                                    value: DoubleReply<number>;
                                }[];
                                sources: ArrayReply<BlobStringReply<string>>;
                            },
                        >;
                    };
                };
                queryIndex: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                QUERYINDEX: {
                    IS_READ_ONLY: true;
                    NOT_KEYED_COMMAND: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        filter: RedisVariadicArgument,
                    ) => void;
                    transformReply: {
                        "2": () => ArrayReply<BlobStringReply<string>>;
                        "3": () => SetReply<BlobStringReply<string>>;
                    };
                };
                range: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            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": (
                            this: void,
                            reply: SamplesRawReply,
                        ) => { timestamp: NumberReply<number>; value: DoubleReply<number> }[];
                    };
                };
                RANGE: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            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": (
                            this: void,
                            reply: SamplesRawReply,
                        ) => { timestamp: NumberReply<number>; value: DoubleReply<number> }[];
                    };
                };
                revRange: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            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": (
                            this: void,
                            reply: SamplesRawReply,
                        ) => { timestamp: NumberReply<number>; value: DoubleReply<number> }[];
                    };
                };
                REVRANGE: {
                    IS_READ_ONLY: true;
                    parseCommand: (
                        this: void,
                        parser: CommandParser,
                        key: RedisArgument,
                        fromTimestamp: Timestamp,
                        toTimestamp: Timestamp,
                        options?: TsRangeOptions,
                    ) => void;
                    transformReply: {
                        "2": (
                            this: void,
                            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": (
                            this: void,
                            reply: SamplesRawReply,
                        ) => { timestamp: NumberReply<number>; value: DoubleReply<number> }[];
                    };
                };
            };
        }

        Redis modules type, defaults to RedisDefaultModules

      • F extends RedisFunctions = RedisFunctions

        Redis functions type, defaults to RedisFunctions

      • S extends RedisScripts = RedisScripts

        Redis scripts type, defaults to RedisScripts

      • RESP extends RespVersions = 2

        Redis RESP protocol version, defaults to 2

      • TYPE_MAPPING extends TypeMapping = TypeMapping

        Redis type mapping, defaults to TypeMapping

      Parameters

      Returns RedisOMManager<M, F, S, RESP, TYPE_MAPPING>

      The connection is created but not opened. You must call connect() to establish the connection. Connection events (error, connect, ready, end, reconnecting) are automatically registered and logged.

    Properties

    name: string

    The name of this manager instance.

    type: "@storehouse/redis-om" = '@storehouse/redis-om'

    Identifier for the manager type.

    Methods

    • Protected

      Adds a Redis-OM schema as a model to this manager. Creates a Repository instance for the schema and stores it internally.

      Parameters

      • m: Schema

        The Redis-OM schema to add

      Returns Schema<Record<string, any>>

      The added schema

    • Closes the Redis connection gracefully using the QUIT command.

      Returns Promise<string>

      A promise that resolves to the Redis server's response to the QUIT command

      await manager.close();

    • Alias for close(). Closes the Redis connection gracefully.

      Returns Promise<string>

      A promise that resolves to the Redis server's response to the QUIT command

      await manager.closeConnection();

    • Creates indexes in Redis for use by the Repository#search method. Does not create a new index for an index that hasn't changed. Requires that RediSearch and RedisJSON are installed on your instance of Redis.

      Returns Promise<void>

      A promise that resolves when all indexes are created

      If RediSearch or RedisJSON modules are not available

      await manager.createIndexes();

    • Removes existing indexes from Redis. Use this method if you want to swap out your indexes because your Entities have changed. Requires that RediSearch and RedisJSON are installed on your instance of Redis.

      Returns Promise<void>

      A promise that resolves when all indexes are dropped

      If RediSearch or RedisJSON modules are not available

      await manager.dropIndexes();
      await manager.createIndexes(); // Recreate with new schema

    • Gets the underlying Redis client connection.

      Returns RedisClientType<M, F, S, RESP, TYPE_MAPPING>

      The Redis client instance

      const client = manager.getConnection();
      await client.set('mykey', 'myvalue');

    • Retrieves a registered Redis-OM Repository by its schema name.

      Type Parameters

      • T extends Record<string, any> = Record<string, any>

        The entity type that defines the structure of data stored in the repository. Defaults to Record<string, any>

      Parameters

      • name: string

        The schema name of the model to retrieve

      Returns Repository<T & EntityData & EntityInternal> | undefined

      The Repository instance typed with the entity structure, or undefined if not found

      // Without type parameter
      const userRepo = manager.getModel('User');
      if (userRepo) {
        const users = await userRepo.search().return.all();
      }

      // With typed entity
      interface User {
        name: string;
        email: string;
        age: number;
      }

      const userRepo = manager.getModel<User>('User');
      if (userRepo) {
        const users = await userRepo.search().return.all();
        // users will be typed as Array<User & Entity>
      }

    • Performs a comprehensive health check on the Redis connection. Tests connectivity by sending a PING command and gathering connection metrics.

      Returns Promise<RedisOMHealthCheckResult>

      A promise that resolves to a detailed health check result including:

      • Connection status (open/ready)
      • Ping response
      • Registered models
      • Response latency
      • Error details (if unhealthy)
      const health = await manager.healthCheck();
      if (health.healthy) {
        console.log(`Redis is healthy. Latency: ${health.details.latency}`);
        console.log(`Models: ${health.details.models?.join(', ')}`);
      } else {
        console.error(`Redis is unhealthy: ${health.message}`);
      }

    • Checks if the Redis connection is currently open.

      Returns Promise<boolean>

      A promise that resolves to true if connected, false otherwise

      if (await manager.isConnected()) {
        console.log('Redis is connected');
      }

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods