Interface RedisDefaultModules

interface RedisDefaultModules {
    bf: {
        ADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        CARD: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => NumberReply<number>);
        };
        EXISTS: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        INFO: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => BfInfoReplyMap);
                3: (() => BfInfoReplyMap);
            };
        };
        INSERT: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items, options?) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        LOADCHUNK: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, iterator, chunk) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        MADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        MEXISTS: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        RESERVE: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, errorRate, capacity, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        SCANDUMP: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, iterator) => void);
            transformReply: ((this, reply) => {
                chunk: BlobStringReply<string>;
                iterator: NumberReply<number>;
            });
        };
        add: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        card: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => NumberReply<number>);
        };
        exists: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        info: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => BfInfoReplyMap);
                3: (() => BfInfoReplyMap);
            };
        };
        insert: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items, options?) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        loadChunk: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, iterator, chunk) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        mAdd: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        mExists: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        reserve: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, errorRate, capacity, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        scanDump: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, iterator) => void);
            transformReply: ((this, reply) => {
                chunk: BlobStringReply<string>;
                iterator: NumberReply<number>;
            });
        };
    };
    cf: {
        ADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        ADDNX: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        COUNT: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: (() => NumberReply<number>);
        };
        DEL: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        EXISTS: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        INFO: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => CfInfoReplyMap);
                3: (() => CfInfoReplyMap);
            };
        };
        INSERT: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items, options?) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        INSERTNX: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items, options?) => void);
            transformReply: (() => ArrayReply<NumberReply<0 | 1 | -1>>);
        };
        LOADCHUNK: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, iterator, chunk) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        RESERVE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, capacity, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        SCANDUMP: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, iterator) => void);
            transformReply: ((this, reply) => {
                chunk: NullReply | BlobStringReply<string>;
                iterator: NumberReply<number>;
            });
        };
        add: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        addNX: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        count: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: (() => NumberReply<number>);
        };
        del: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        exists: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, item) => void);
            transformReply: {
                2: ((reply) => boolean);
                3: (() => BooleanReply<boolean>);
            };
        };
        info: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => CfInfoReplyMap);
                3: (() => CfInfoReplyMap);
            };
        };
        insert: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items, options?) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        insertNX: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items, options?) => void);
            transformReply: (() => ArrayReply<NumberReply<0 | 1 | -1>>);
        };
        loadChunk: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, iterator, chunk) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        reserve: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, capacity, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        scanDump: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, iterator) => void);
            transformReply: ((this, reply) => {
                chunk: NullReply | BlobStringReply<string>;
                iterator: NumberReply<number>;
            });
        };
    };
    cms: {
        INCRBY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        INFO: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => CmsInfoReply);
                3: (() => CmsInfoReply);
            };
        };
        INITBYDIM: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, width, depth) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        INITBYPROB: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, error, probability) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        MERGE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, destination, source) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        QUERY: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        incrBy: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        info: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => CmsInfoReply);
                3: (() => CmsInfoReply);
            };
        };
        initByDim: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, width, depth) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        initByProb: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, error, probability) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        merge: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, destination, source) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        query: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
    };
    ft: {
        AGGREGATE: {
            IS_READ_ONLY: false;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((rawReply, preserve?, typeMapping?) => AggregateReply);
                3: ((rawReply, preserve?, typeMapping?) => AggregateReply);
            };
        };
        AGGREGATE_WITHCURSOR: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
                3: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
            };
        };
        ALIASADD: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, alias, index) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        ALIASDEL: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, alias) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        ALIASUPDATE: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, alias, index) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        ALTER: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, schema) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        CONFIG_GET: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, option) => void);
            transformReply: ((this, reply) => Record<string, unknown>);
        };
        CONFIG_SET: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, property, value) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        CREATE: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, schema, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        CURSOR_DEL: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, cursorId) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        CURSOR_READ: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, cursor, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
                3: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
            };
        };
        DICTADD: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, dictionary, term) => void);
            transformReply: (() => NumberReply<number>);
        };
        DICTDEL: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, dictionary, term) => void);
            transformReply: (() => NumberReply<number>);
        };
        DICTDUMP: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, dictionary) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        DROPINDEX: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, options?) => void);
            transformReply: {
                2: (() => SimpleStringReply<"OK">);
                3: (() => NumberReply<number>);
            };
        };
        EXPLAIN: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: (() => SimpleStringReply<string>);
        };
        EXPLAINCLI: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>>);
        };
        HYBRID: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, options) => void);
            transformReply: {
                2: ((reply, _preserve?, _typeMapping?) => HybridSearchResult);
                3: ((reply, _preserve?, _typeMapping?) => HybridSearchResult);
            };
        };
        INFO: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => InfoReply);
                3: (() => InfoReply);
            };
        };
        PROFILEAGGREGATE: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
                3: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
            };
        };
        PROFILESEARCH: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
                3: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
            };
        };
        SEARCH: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, _preserve?, _typeMapping?) => SearchReply);
                3: ((rawReply, preserve?, typeMapping?) => SearchReply);
            };
        };
        SEARCH_NOCONTENT: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply) => SearchNoContentReply);
                3: ((reply, preserve?, typeMapping?) => SearchNoContentReply);
            };
        };
        SPELLCHECK: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((rawReply) => {
                    suggestions: {
                        score: number;
                        suggestion: string;
                    }[];
                    term: string;
                }[]);
                3: ((rawReply) => {
                    suggestions: {
                        score: number;
                        suggestion: string;
                    }[];
                    term: string;
                }[]);
            };
        };
        SUGADD: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, string, score, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        SUGDEL: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, string) => void);
            transformReply: (() => NumberReply<0 | 1>);
        };
        SUGGET: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: (() => NullReply | ArrayReply<BlobStringReply<string>>);
        };
        SUGGET_WITHPAYLOADS: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: ((this, reply) => null | {
                payload: BlobStringReply<string>;
                suggestion: BlobStringReply<string>;
            }[]);
        };
        SUGGET_WITHSCORES: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => null | {
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
                3: ((reply) => null | {
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
            };
        };
        SUGGET_WITHSCORES_WITHPAYLOADS: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => null | {
                    payload: BlobStringReply<string>;
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
                3: ((reply) => null | {
                    payload: BlobStringReply<string>;
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
            };
        };
        SUGLEN: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => NumberReply<number>);
        };
        SYNDUMP: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index) => void);
            transformReply: {
                2: ((reply) => Record<string, ArrayReply<BlobStringReply<string>>>);
                3: (() => MapReply<BlobStringReply<string>, ArrayReply<BlobStringReply<string>>>);
            };
        };
        SYNUPDATE: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, groupId, terms, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        TAGVALS: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, fieldName) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        _LIST: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        _list: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        aggregate: {
            IS_READ_ONLY: false;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((rawReply, preserve?, typeMapping?) => AggregateReply);
                3: ((rawReply, preserve?, typeMapping?) => AggregateReply);
            };
        };
        aggregateWithCursor: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
                3: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
            };
        };
        aliasAdd: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, alias, index) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        aliasDel: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, alias) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        aliasUpdate: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, alias, index) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        alter: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, schema) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        configGet: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, option) => void);
            transformReply: ((this, reply) => Record<string, unknown>);
        };
        configSet: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, property, value) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        create: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, schema, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        cursorDel: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, cursorId) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        cursorRead: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, cursor, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
                3: ((reply, preserve?, typeMapping?) => AggregateWithCursorReply);
            };
        };
        dictAdd: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, dictionary, term) => void);
            transformReply: (() => NumberReply<number>);
        };
        dictDel: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, dictionary, term) => void);
            transformReply: (() => NumberReply<number>);
        };
        dictDump: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, dictionary) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        dropIndex: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, options?) => void);
            transformReply: {
                2: (() => SimpleStringReply<"OK">);
                3: (() => NumberReply<number>);
            };
        };
        explain: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: (() => SimpleStringReply<string>);
        };
        explainCli: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>>);
        };
        hybrid: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, options) => void);
            transformReply: {
                2: ((reply, _preserve?, _typeMapping?) => HybridSearchResult);
                3: ((reply, _preserve?, _typeMapping?) => HybridSearchResult);
            };
        };
        info: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => InfoReply);
                3: (() => InfoReply);
            };
        };
        profileAggregate: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
                3: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
            };
        };
        profileSearch: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
                3: ((reply, preserve?, typeMapping?) => ProfileReplyResp2);
            };
        };
        search: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply, _preserve?, _typeMapping?) => SearchReply);
                3: ((rawReply, preserve?, typeMapping?) => SearchReply);
            };
        };
        searchNoContent: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((reply) => SearchNoContentReply);
                3: ((reply, preserve?, typeMapping?) => SearchNoContentReply);
            };
        };
        spellCheck: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, query, options?) => void);
            transformReply: {
                2: ((rawReply) => {
                    suggestions: {
                        score: number;
                        suggestion: string;
                    }[];
                    term: string;
                }[]);
                3: ((rawReply) => {
                    suggestions: {
                        score: number;
                        suggestion: string;
                    }[];
                    term: string;
                }[]);
            };
        };
        sugAdd: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, string, score, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        sugDel: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, string) => void);
            transformReply: (() => NumberReply<0 | 1>);
        };
        sugGet: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: (() => NullReply | ArrayReply<BlobStringReply<string>>);
        };
        sugGetWithPayloads: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: ((this, reply) => null | {
                payload: BlobStringReply<string>;
                suggestion: BlobStringReply<string>;
            }[]);
        };
        sugGetWithScores: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => null | {
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
                3: ((reply) => null | {
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
            };
        };
        sugGetWithScoresWithPayloads: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, prefix, options?) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => null | {
                    payload: BlobStringReply<string>;
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
                3: ((reply) => null | {
                    payload: BlobStringReply<string>;
                    score: DoubleReply<number>;
                    suggestion: BlobStringReply<string>;
                }[]);
            };
        };
        sugLen: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => NumberReply<number>);
        };
        synDump: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index) => void);
            transformReply: {
                2: ((reply) => Record<string, ArrayReply<BlobStringReply<string>>>);
                3: (() => MapReply<BlobStringReply<string>, ArrayReply<BlobStringReply<string>>>);
            };
        };
        synUpdate: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, groupId, terms, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        tagVals: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, index, fieldName) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
    };
    json: {
        ARRAPPEND: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, json, ...jsons) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        ARRINDEX: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, path, json, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        ARRINSERT: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, index, json, ...jsons) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        ARRLEN: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        ARRPOP: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: ((this, reply) => null | string | number | boolean | NullReply | Date | {
                [key: string]: lib/commands/generic-transformers;
            } | (NullReply | RedisJSON)[]);
        };
        ARRTRIM: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, start, stop) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        CLEAR: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        DEBUG_MEMORY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        DEL: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        FORGET: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        GET: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: ((json) => NullReply | RedisJSON);
        };
        MERGE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, value) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        MGET: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, keys, path) => void);
            transformReply: ((this, reply) => (NullReply | RedisJSON)[]);
        };
        MSET: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, items) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        NUMINCRBY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, by) => void);
            transformReply: {
                2: ((reply) => number | (null | number)[]);
                3: (() => ArrayReply<NullReply | NumberReply<number> | DoubleReply<number>>);
            };
        };
        NUMMULTBY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, by) => void);
            transformReply: {
                2: ((reply) => number | (null | number)[]);
                3: (() => ArrayReply<NullReply | NumberReply<number> | DoubleReply<number>>);
            };
        };
        OBJKEYS: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>> | ArrayReply<NullReply | ArrayReply<BlobStringReply<string>>>);
        };
        OBJLEN: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        SET: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, json, options?) => void);
            transformReply: (() => NullReply | SimpleStringReply<"OK">);
        };
        STRAPPEND: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, append, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        STRLEN: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        TOGGLE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path) => void);
            transformReply: (() => NullReply | NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        TYPE: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: {
                2: (() => NullReply | BlobStringReply<string> | ArrayReply<NullReply | BlobStringReply<string>>);
                3: ((reply) => NullReply | BlobStringReply<string> | ArrayReply<NullReply | BlobStringReply<string>>);
            };
        };
        arrAppend: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, json, ...jsons) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        arrIndex: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, path, json, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        arrInsert: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, index, json, ...jsons) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        arrLen: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        arrPop: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: ((this, reply) => null | string | number | boolean | NullReply | Date | (NullReply | RedisJSON)[] | {
                [key: string]: lib/commands/generic-transformers;
            });
        };
        arrTrim: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, start, stop) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        clear: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        debugMemory: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        del: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        forget: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        get: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: ((json) => NullReply | RedisJSON);
        };
        mGet: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, keys, path) => void);
            transformReply: ((this, reply) => (NullReply | RedisJSON)[]);
        };
        mSet: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, items) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        merge: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, value) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        numIncrBy: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, by) => void);
            transformReply: {
                2: ((reply) => number | (null | number)[]);
                3: (() => ArrayReply<NullReply | NumberReply<number> | DoubleReply<number>>);
            };
        };
        numMultBy: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, by) => void);
            transformReply: {
                2: ((reply) => number | (null | number)[]);
                3: (() => ArrayReply<NullReply | NumberReply<number> | DoubleReply<number>>);
            };
        };
        objKeys: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>> | ArrayReply<NullReply | ArrayReply<BlobStringReply<string>>>);
        };
        objLen: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        set: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path, json, options?) => void);
            transformReply: (() => NullReply | SimpleStringReply<"OK">);
        };
        strAppend: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, append, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        strLen: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        toggle: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, path) => void);
            transformReply: (() => NullReply | NumberReply<number> | ArrayReply<NullReply | NumberReply<number>>);
        };
        type: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: {
                2: (() => NullReply | BlobStringReply<string> | ArrayReply<NullReply | BlobStringReply<string>>);
                3: ((reply) => NullReply | BlobStringReply<string> | ArrayReply<NullReply | BlobStringReply<string>>);
            };
        };
    };
    tDigest: {
        ADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        BYRANK: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, ranks) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        BYREVRANK: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, ranks) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        CDF: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        CREATE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        INFO: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => TdInfoReplyMap);
                3: (() => TdInfoReplyMap);
            };
        };
        MAX: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>);
                3: (() => DoubleReply<number>);
            };
        };
        MERGE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, destination, source, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        MIN: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>);
                3: (() => DoubleReply<number>);
            };
        };
        QUANTILE: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, quantiles) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        RANK: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        RESET: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        REVRANK: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        TRIMMED_MEAN: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, lowCutPercentile, highCutPercentile) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>);
                3: (() => DoubleReply<number>);
            };
        };
        add: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        byRank: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, ranks) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        byRevRank: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, ranks) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        cdf: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        create: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        info: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => TdInfoReplyMap);
                3: (() => TdInfoReplyMap);
            };
        };
        max: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>);
                3: (() => DoubleReply<number>);
            };
        };
        merge: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, destination, source, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        min: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>);
                3: (() => DoubleReply<number>);
            };
        };
        quantile: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, quantiles) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>[]);
                3: (() => ArrayReply<DoubleReply<number>>);
            };
        };
        rank: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        reset: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        revRank: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, values) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        trimmedMean: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, lowCutPercentile, highCutPercentile) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => DoubleReply<number>);
                3: (() => DoubleReply<number>);
            };
        };
    };
    topK: {
        ADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>>);
        };
        COUNT: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        INCRBY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NullReply | SimpleStringReply<string>>);
        };
        INFO: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => TopKInfoReplyMap);
                3: (() => TopKInfoReplyMap);
            };
        };
        LIST: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>>);
        };
        LIST_WITHCOUNT: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: ((this, rawReply) => {
                count: NumberReply<number>;
                item: BlobStringReply<string>;
            }[]);
        };
        QUERY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        RESERVE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, topK, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        add: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>>);
        };
        count: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NumberReply<number>>);
        };
        incrBy: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: (() => ArrayReply<NullReply | SimpleStringReply<string>>);
        };
        info: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, preserve?, typeMapping?) => TopKInfoReplyMap);
                3: (() => TopKInfoReplyMap);
            };
        };
        list: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: (() => ArrayReply<BlobStringReply<string>>);
        };
        listWithCount: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: ((this, rawReply) => {
                count: NumberReply<number>;
                item: BlobStringReply<string>;
            }[]);
        };
        query: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, items) => void);
            transformReply: {
                2: ((reply) => boolean[]);
                3: (() => ArrayReply<BooleanReply<boolean>>);
            };
        };
        reserve: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, topK, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
    };
    ts: {
        ADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, timestamp, value, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        ALTER: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        CREATE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        CREATERULE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, sourceKey, destinationKey, aggregationType, bucketDuration, alignTimestamp?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        DECRBY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, value, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        DEL: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp) => void);
            transformReply: (() => NumberReply<number>);
        };
        DELETERULE: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, sourceKey, destinationKey) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        GET: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: {
                2: ((this, reply) => null | {
                    timestamp: NumberReply<number>;
                    value: number;
                });
                3: ((this, reply) => null | {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                });
            };
        };
        INCRBY: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, value, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        INFO: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, _, typeMapping?) => InfoReply);
                3: ((reply, preserve?, typeMapping?) => InfoReply);
            };
        };
        INFO_DEBUG: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => InfoDebugReply);
                3: ((reply, preserve?, typeMapping?) => InfoDebugReply);
            };
        };
        MADD: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, toAdd) => void);
            transformReply: (() => ArrayReply<SimpleErrorReply | NumberReply<number>>);
        };
        MGET: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => MapReply<BlobStringReply<string>, {
                    sample: {
                        timestamp: NumberReply<number>;
                        value: number;
                    };
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    sample: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    };
                }>);
            };
        };
        MGET_SELECTED_LABELS: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, filter, selectedLabels, options?) => void);
            transformReply: {
                2(this, reply, _, typeMapping?): MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    sample: {
                        timestamp: NumberReply<number>;
                        value: number;
                    };
                }>;
                3(this, reply): 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, parser, filter, options?) => void);
            transformReply: {
                2(this, reply, _, typeMapping?): MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    sample: {
                        timestamp: NumberReply<number>;
                        value: number;
                    };
                }>;
                3(this, reply): 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, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]>);
            };
        };
        MRANGE_GROUPBY: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        MRANGE_MULTIAGGR: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]>);
            };
        };
        MRANGE_SELECTED_LABELS: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        MRANGE_SELECTED_LABELS_GROUPBY: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        MRANGE_SELECTED_LABELS_MULTIAGGR: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        MRANGE_WITHLABELS: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => 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, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                    sources: string[] | Buffer[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                    sources: ArrayReply<BlobStringReply<string>>;
                }>);
            };
        };
        MRANGE_WITHLABELS_MULTIAGGR: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        MREVRANGE: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]>);
            };
        };
        MREVRANGE_GROUPBY: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        MREVRANGE_MULTIAGGR: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]>);
            };
        };
        MREVRANGE_SELECTED_LABELS: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        MREVRANGE_SELECTED_LABELS_GROUPBY: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        MREVRANGE_SELECTED_LABELS_MULTIAGGR: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        MREVRANGE_WITHLABELS: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => 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, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                    sources: string[] | Buffer[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                    sources: ArrayReply<BlobStringReply<string>>;
                }>);
            };
        };
        MREVRANGE_WITHLABELS_MULTIAGGR: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        QUERYINDEX: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, filter) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        RANGE: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options?) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]);
            };
        };
        RANGE_MULTIAGGR: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]);
            };
        };
        REVRANGE: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options?) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]);
            };
        };
        REVRANGE_MULTIAGGR: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]);
            };
        };
        add: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, timestamp, value, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        alter: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        create: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        createRule: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, sourceKey, destinationKey, aggregationType, bucketDuration, alignTimestamp?) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        decrBy: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, value, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        del: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp) => void);
            transformReply: (() => NumberReply<number>);
        };
        deleteRule: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, sourceKey, destinationKey) => void);
            transformReply: (() => SimpleStringReply<"OK">);
        };
        get: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, options?) => void);
            transformReply: {
                2: ((this, reply) => null | {
                    timestamp: NumberReply<number>;
                    value: number;
                });
                3: ((this, reply) => null | {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                });
            };
        };
        incrBy: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, key, value, options?) => void);
            transformReply: (() => NumberReply<number>);
        };
        info: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((reply, _, typeMapping?) => InfoReply);
                3: ((reply, preserve?, typeMapping?) => InfoReply);
            };
        };
        infoDebug: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => InfoDebugReply);
                3: ((reply, preserve?, typeMapping?) => InfoDebugReply);
            };
        };
        mAdd: {
            IS_READ_ONLY: false;
            parseCommand: ((this, parser, toAdd) => void);
            transformReply: (() => ArrayReply<SimpleErrorReply | NumberReply<number>>);
        };
        mGet: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _, typeMapping?) => MapReply<BlobStringReply<string>, {
                    sample: {
                        timestamp: NumberReply<number>;
                        value: number;
                    };
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    sample: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    };
                }>);
            };
        };
        mGetSelectedLabels: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, filter, selectedLabels, options?) => void);
            transformReply: {
                2(this, reply, _, typeMapping?): MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    sample: {
                        timestamp: NumberReply<number>;
                        value: number;
                    };
                }>;
                3(this, reply): MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    sample: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    };
                }>;
            };
        };
        mGetWithLabels: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, filter, options?) => void);
            transformReply: {
                2(this, reply, _, typeMapping?): MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    sample: {
                        timestamp: NumberReply<number>;
                        value: number;
                    };
                }>;
                3(this, reply): 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, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]>);
            };
        };
        mRangeGroupBy: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRangeMultiAggr: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]>);
            };
        };
        mRangeSelectedLabels: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRangeSelectedLabelsGroupBy: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRangeSelectedLabelsMultiAggr: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        mRangeWithLabels: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRangeWithLabelsGroupBy: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                    sources: string[] | Buffer[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                    sources: ArrayReply<BlobStringReply<string>>;
                }>);
            };
        };
        mRangeWithLabelsMultiAggr: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        mRevRange: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]>);
            };
        };
        mRevRangeGroupBy: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRevRangeMultiAggr: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]>);
            };
        };
        mRevRangeSelectedLabels: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRevRangeSelectedLabelsGroupBy: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRevRangeSelectedLabelsMultiAggr: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, selectedLabels, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, NullReply | BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        mRevRangeWithLabels: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                }>);
            };
        };
        mRevRangeWithLabelsGroupBy: {
            IS_READ_ONLY: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, groupBy, options?) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: number;
                    }[];
                    sources: string[] | Buffer[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        value: DoubleReply<number>;
                    }[];
                    sources: ArrayReply<BlobStringReply<string>>;
                }>);
            };
        };
        mRevRangeWithLabelsMultiAggr: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((parser, fromTimestamp, toTimestamp, filter, options) => void);
            transformReply: {
                2: ((this, reply, _?, typeMapping?) => MapReply<BlobStringReply<string>, {
                    labels: Record<string, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: number[];
                    }[];
                }>);
                3: ((this, reply) => MapReply<BlobStringReply<string>, {
                    labels: MapReply<BlobStringReply<string>, BlobStringReply<string>>;
                    samples: {
                        timestamp: NumberReply<number>;
                        values: DoubleReply<number>[];
                    }[];
                }>);
            };
        };
        queryIndex: {
            IS_READ_ONLY: true;
            NOT_KEYED_COMMAND: true;
            parseCommand: ((this, parser, filter) => void);
            transformReply: {
                2: (() => ArrayReply<BlobStringReply<string>>);
                3: (() => SetReply<BlobStringReply<string>>);
            };
        };
        range: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options?) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]);
            };
        };
        rangeMultiAggr: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]);
            };
        };
        revRange: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options?) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: number;
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    value: DoubleReply<number>;
                }[]);
            };
        };
        revRangeMultiAggr: {
            IS_READ_ONLY: true;
            parseCommand: ((this, parser, key, fromTimestamp, toTimestamp, options) => void);
            transformReply: {
                2: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: number[];
                }[]);
                3: ((this, reply) => {
                    timestamp: NumberReply<number>;
                    values: DoubleReply<number>[];
                }[]);
            };
        };
    };
}