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