Function getConnection

getConnection<
    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> }[];
                };
            };
        };
    },
    F extends RedisFunctions = RedisFunctions,
    S extends RedisScripts = RedisScripts,
    RESP extends RespVersions = 2,
    TYPE_MAPPING extends TypeMapping = TypeMapping,
>(
    registry: Registry,
    managerName?: string,
): RedisClientType<M, F, S, RESP, TYPE_MAPPING>