KinfeMichael Tariku
e8997d922d
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
24795 lines
809 KiB
TypeScript
24795 lines
809 KiB
TypeScript
import { StandardSchemaV1 } from "@standard-schema/spec";
|
|
|
|
import Deque from "denque";
|
|
|
|
import { SrvRecord } from "dns";
|
|
|
|
import { EventEmitter } from "events";
|
|
|
|
import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from "net";
|
|
|
|
import { Readable, ReadableOptions } from "stream";
|
|
|
|
import { ConnectionOptions, TLSSocket } from "tls";
|
|
|
|
declare abstract class AbstractConnector {
|
|
#private;
|
|
firstError?: Error;
|
|
protected connecting: boolean;
|
|
protected stream: NetStream;
|
|
constructor(disconnectTimeout: number);
|
|
check(info: any): boolean;
|
|
disconnect(): void;
|
|
abstract connect(_: ErrorEmitter): Promise<NetStream>;
|
|
}
|
|
|
|
type AddSet = CommandNameFlags["ENTER_SUBSCRIBER_MODE"][number];
|
|
|
|
interface AddressFromResponse {
|
|
port: string;
|
|
ip: string;
|
|
flags?: string | undefined;
|
|
}
|
|
|
|
type ArgumentTransformer = (args: any[]) => any[];
|
|
|
|
type ArgumentType = string | Buffer | number | (string | Buffer | number | any[])[];
|
|
|
|
type AsNumber<K> = K extends `${infer N extends number}` ? N | K : never;
|
|
|
|
type AssistantMessage = {
|
|
role: "assistant";
|
|
status: AssistantMessageStatus;
|
|
parts: AssistantMessagePart[];
|
|
content: AssistantMessagePart[];
|
|
metadata: {
|
|
unstable_state: ReadonlyJSONValue;
|
|
unstable_data: ReadonlyJSONValue[];
|
|
unstable_annotations: ReadonlyJSONValue[];
|
|
steps: AssistantMessageStepMetadata[];
|
|
custom: Record<string, unknown>;
|
|
timing?: AssistantMessageTiming;
|
|
};
|
|
};
|
|
|
|
declare class AssistantMessageAccumulator extends TransformStream<AssistantStreamChunk, AssistantMessage> {
|
|
constructor(_param0?: {
|
|
initialMessage?: AssistantMessage;
|
|
throttle?: boolean;
|
|
onError?: (error: string) => void;
|
|
strict?: boolean | undefined;
|
|
});
|
|
}
|
|
|
|
type AssistantMessagePart = TextPart | ReasoningPart | ToolCallPart | SourcePart | FilePart | DataPart;
|
|
|
|
type AssistantMessageStatus = {
|
|
type: "running";
|
|
} | {
|
|
type: "requires-action";
|
|
reason: "tool-calls";
|
|
} | {
|
|
type: "complete";
|
|
reason: "stop" | "unknown";
|
|
} | {
|
|
type: "incomplete";
|
|
reason: "cancelled" | "content-filter" | "error" | "length" | "other" | "tool-calls";
|
|
error?: ReadonlyJSONValue;
|
|
};
|
|
|
|
type AssistantMessageStepMetadata = {
|
|
state: "started";
|
|
messageId: string;
|
|
} | {
|
|
state: "finished";
|
|
messageId: string;
|
|
finishReason: "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls" | "unknown";
|
|
usage?: AssistantMessageStepUsage;
|
|
isContinued: boolean;
|
|
};
|
|
|
|
type AssistantMessageStepUsage = {
|
|
inputTokens: number;
|
|
outputTokens: number;
|
|
};
|
|
|
|
declare class AssistantMessageStream {
|
|
readonly readable: ReadableStream<AssistantMessage>;
|
|
constructor(readable: ReadableStream<AssistantMessage>);
|
|
static fromAssistantStream(stream: AssistantStream): AssistantMessageStream;
|
|
unstable_result(): Promise<AssistantMessage>;
|
|
[Symbol.asyncIterator](): AsyncIterator<AssistantMessage, any, any>;
|
|
tee(): [
|
|
AssistantMessageStream,
|
|
AssistantMessageStream
|
|
];
|
|
}
|
|
|
|
type AssistantMessageTiming = {
|
|
streamStartTime: number;
|
|
firstTokenTime?: number;
|
|
totalStreamTime?: number;
|
|
tokenCount?: number;
|
|
tokensPerSecond?: number;
|
|
totalChunks: number;
|
|
toolCallCount: number;
|
|
};
|
|
|
|
type AssistantMetaStreamChunk = (AssistantStreamChunk & {
|
|
type: "part-finish" | "text-delta";
|
|
meta: PartInit;
|
|
}) | (AssistantStreamChunk & {
|
|
type: "result" | "tool-call-args-text-finish";
|
|
meta: PartInit & {
|
|
type: "tool-call";
|
|
};
|
|
}) | (AssistantStreamChunk & {
|
|
type: Exclude<AssistantStreamChunk["type"], "part-finish" | "result" | "text-delta" | "tool-call-args-text-finish">;
|
|
});
|
|
|
|
declare class AssistantMetaTransformStream extends TransformStream<AssistantStreamChunk, AssistantMetaStreamChunk> {
|
|
constructor();
|
|
}
|
|
|
|
type AssistantStream = ReadableStream<AssistantStreamChunk>;
|
|
|
|
declare const AssistantStream: {
|
|
toResponse(stream: AssistantStream, transformer: AssistantStreamEncoder): Response;
|
|
fromResponse(response: Response, transformer: ReadableWritablePair<AssistantStreamChunk, Uint8Array<ArrayBuffer>>): ReadableStream<AssistantStreamChunk>;
|
|
toByteStream(stream: AssistantStream, transformer: ReadableWritablePair<Uint8Array<ArrayBuffer>, AssistantStreamChunk>): ReadableStream<Uint8Array<ArrayBuffer>>;
|
|
fromByteStream(readable: ReadableStream<Uint8Array<ArrayBuffer>>, transformer: ReadableWritablePair<AssistantStreamChunk, Uint8Array<ArrayBuffer>>): ReadableStream<AssistantStreamChunk>;
|
|
};
|
|
|
|
type AssistantStreamChunk = {
|
|
readonly path: readonly number[];
|
|
} & ({
|
|
readonly type: "part-start";
|
|
readonly part: PartInit;
|
|
} | {
|
|
readonly type: "part-finish";
|
|
} | {
|
|
readonly type: "tool-call-args-text-finish";
|
|
} | {
|
|
readonly type: "text-delta";
|
|
readonly textDelta: string;
|
|
} | {
|
|
readonly type: "annotations";
|
|
readonly annotations: ReadonlyJSONValue[];
|
|
} | {
|
|
readonly type: "data";
|
|
readonly data: ReadonlyJSONValue[];
|
|
} | {
|
|
readonly type: "step-start";
|
|
readonly messageId: string;
|
|
} | {
|
|
readonly type: "step-finish";
|
|
readonly finishReason: "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls" | "unknown";
|
|
readonly usage: {
|
|
readonly inputTokens: number;
|
|
readonly outputTokens: number;
|
|
};
|
|
readonly isContinued: boolean;
|
|
} | {
|
|
readonly type: "message-finish";
|
|
readonly finishReason: "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls" | "unknown";
|
|
readonly usage: {
|
|
readonly inputTokens: number;
|
|
readonly outputTokens: number;
|
|
};
|
|
} | {
|
|
readonly type: "result";
|
|
readonly artifact?: ReadonlyJSONValue;
|
|
readonly result: ReadonlyJSONValue;
|
|
readonly isError: boolean;
|
|
readonly modelContent?: readonly ToolModelContentPart[];
|
|
readonly messages?: ReadonlyJSONValue;
|
|
} | {
|
|
readonly type: "error";
|
|
readonly error: string;
|
|
readonly code?: string;
|
|
readonly severity?: "critical" | "info" | "warning";
|
|
} | {
|
|
readonly type: "update-state";
|
|
readonly operations: AssistantTransportStateOperation[];
|
|
});
|
|
|
|
type AssistantStreamController = {
|
|
appendText(textDelta: string): void;
|
|
appendReasoning(reasoningDelta: string, options?: ReasoningPartInit): void;
|
|
appendSource(options: SourcePart): void;
|
|
appendFile(options: FilePart): void;
|
|
appendData(options: DataPart): void;
|
|
addTextPart(): TextStreamController;
|
|
addReasoningPart(options?: ReasoningPartInit): TextStreamController;
|
|
addToolCallPart(options: string): ToolCallStreamController;
|
|
addToolCallPart(options: ToolCallPartInit): ToolCallStreamController;
|
|
enqueue(chunk: AssistantStreamChunk): void;
|
|
merge(stream: AssistantStream): void;
|
|
close(): void;
|
|
withParentId(parentId: string): AssistantStreamController;
|
|
};
|
|
|
|
type AssistantStreamEncoder = ReadableWritablePair<Uint8Array<ArrayBuffer>, AssistantStreamChunk> & {
|
|
headers?: Headers;
|
|
};
|
|
|
|
type AssistantStreamOptions = {
|
|
strict?: boolean | undefined;
|
|
};
|
|
|
|
declare class AssistantTransformStream<I> extends TransformStream<I, AssistantStreamChunk> {
|
|
constructor(transformer: AssistantTransformer<I>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<AssistantStreamChunk>);
|
|
}
|
|
|
|
type AssistantTransformer<I> = {
|
|
strict?: boolean | undefined;
|
|
flush?: AssistantTransformerFlushCallback;
|
|
start?: AssistantTransformerStartCallback;
|
|
transform?: AssistantTransformerTransformCallback<I>;
|
|
};
|
|
|
|
type AssistantTransformerFlushCallback = (controller: AssistantStreamController) => void | PromiseLike<void>;
|
|
|
|
type AssistantTransformerStartCallback = (controller: AssistantStreamController) => void | PromiseLike<void>;
|
|
|
|
type AssistantTransformerTransformCallback<I> = (chunk: I, controller: AssistantStreamController) => void | PromiseLike<void>;
|
|
|
|
declare class AssistantTransportDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, AssistantStreamChunk> {
|
|
constructor(options?: {
|
|
strict?: boolean | undefined;
|
|
});
|
|
}
|
|
|
|
declare class AssistantTransportEncoder extends PipeableTransformStream<AssistantStreamChunk, Uint8Array<ArrayBuffer>> implements AssistantStreamEncoder {
|
|
headers: Headers;
|
|
constructor();
|
|
}
|
|
|
|
type AssistantTransportStateOperation = {
|
|
readonly type: "set";
|
|
readonly path: readonly string[];
|
|
readonly value: ReadonlyJSONValue;
|
|
} | {
|
|
readonly type: "append-text";
|
|
readonly path: readonly string[];
|
|
readonly value: string;
|
|
};
|
|
|
|
type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
|
|
|
|
type AttachmentLike = {
|
|
content: readonly MessagePartLike[];
|
|
};
|
|
|
|
type BackendTool<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolBase<TArgs, TResult> & {
|
|
type: "backend";
|
|
description?: undefined;
|
|
parameters?: undefined;
|
|
disabled?: undefined;
|
|
execute?: undefined;
|
|
toModelOutput?: undefined;
|
|
experimental_onSchemaValidationError?: undefined;
|
|
providerOptions?: undefined;
|
|
};
|
|
|
|
type BackendToolDeclaration<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolBase<TArgs, TResult> & {
|
|
type: "backend";
|
|
description?: string | undefined;
|
|
parameters?: StandardSchemaV1<TArgs> | JSONSchema7 | undefined;
|
|
disabled?: boolean;
|
|
execute?: ToolExecuteFunction<TArgs, TResult>;
|
|
toModelOutput?: ToolModelOutputFunction<TArgs, TResult>;
|
|
experimental_onSchemaValidationError?: OnSchemaValidationErrorFunction<TResult>;
|
|
providerOptions?: ProviderOptions;
|
|
};
|
|
|
|
interface BatchOperationContext {
|
|
batchMode: "MULTI";
|
|
batchSize: number;
|
|
database: number;
|
|
serverAddress: string;
|
|
serverPort: number | undefined;
|
|
}
|
|
|
|
type Callback<T = any> = (err?: Error | null, result?: T) => void;
|
|
|
|
interface ChainableCommander<Mapping extends "resp2" | "resp3" = "resp2"> extends RedisCommander<{
|
|
type: "pipeline";
|
|
mapping: Mapping;
|
|
}> {
|
|
length: number;
|
|
}
|
|
|
|
type ClientContext = {
|
|
type: keyof ResultTypes<unknown, unknown>;
|
|
mapping?: "resp2" | "resp3";
|
|
};
|
|
|
|
declare class Cluster<ReplyMapping extends ReplyMappingMode = "legacy"> extends Commander<{
|
|
type: "default";
|
|
mapping: ReplyMapping extends "resp3" ? "resp3" : "resp2";
|
|
}> {
|
|
#private;
|
|
options: ClusterOptions;
|
|
slots: NodeKey[][];
|
|
status: ClusterStatus;
|
|
_groupsIds: {
|
|
[key: string]: number;
|
|
};
|
|
_groupsBySlot: number[];
|
|
isCluster: boolean;
|
|
constructor(startupNodes: ClusterNode[], options?: ClusterOptionsWithReplyMapping<ReplyMapping>);
|
|
connect(): Promise<void>;
|
|
disconnect(reconnect?: boolean): void;
|
|
quit(callback?: Callback<"OK">): Promise<"OK">;
|
|
duplicate<OverrideOptions extends ClusterOptionsWithReplyMapping<ReplyMappingMode> | undefined = undefined>(overrideStartupNodes?: ClusterNode[], overrideOptions?: OverrideOptions): Cluster<ReplyMappingFromClusterOptions<ReplyMapping, OverrideOptions>>;
|
|
nodes(role?: NodeRole): Redis[];
|
|
delayUntilReady(callback: Callback): void;
|
|
get autoPipelineQueueSize(): number;
|
|
refreshSlotsCache(callback?: Callback<void>): void;
|
|
sendCommand(command: Command, stream?: WriteableStream, node?: any): unknown;
|
|
sscanStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
sscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
hscanStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
hscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
zscanStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
zscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
handleError(error: Error, ttl: {
|
|
value?: any;
|
|
}, handlers: any): void;
|
|
}
|
|
|
|
interface Cluster<ReplyMapping extends "legacy" | "resp3" = "legacy"> extends EventEmitter {
|
|
}
|
|
|
|
interface Cluster<ReplyMapping extends "legacy" | "resp3" = "legacy"> extends Transaction<ReplyMapping extends "resp3" ? "resp3" : "resp2"> {
|
|
}
|
|
|
|
type ClusterNode = string | number | {
|
|
host?: string | undefined;
|
|
port?: number | undefined;
|
|
};
|
|
|
|
type ClusterNodeRetryStrategy = RetryStrategy;
|
|
|
|
interface ClusterOptions extends CommanderOptions {
|
|
clusterRetryStrategy?: ((times: number, reason?: Error) => number | void | null) | null | undefined;
|
|
enableOfflineQueue?: boolean | undefined;
|
|
enableReadyCheck?: boolean | undefined;
|
|
scaleReads?: NodeRole | Function | undefined;
|
|
maxRedirections?: number | undefined;
|
|
retryDelayOnFailover?: number | undefined;
|
|
retryDelayOnClusterDown?: number | undefined;
|
|
retryDelayOnTryAgain?: number | undefined;
|
|
retryDelayOnMoved?: number | undefined;
|
|
slotsRefreshTimeout?: number | undefined;
|
|
slotsRefreshInterval?: number | undefined;
|
|
shardedSubscribers?: boolean | undefined;
|
|
clusterNodeRetryStrategy?: ClusterNodeRetryStrategy;
|
|
redisOptions?: Omit<RedisOptions, "enableOfflineQueue" | "himportFieldsets" | "host" | "path" | "port" | "readOnly" | "retryStrategy" | "sentinels"> | undefined;
|
|
lazyConnect?: boolean | undefined;
|
|
useSRVRecords?: boolean | undefined;
|
|
resolveSrv?: DNSResolveSrvFunction | undefined;
|
|
dnsLookup?: DNSLookupFunction | undefined;
|
|
natMap?: NatMap | undefined;
|
|
enableAutoPipelining?: boolean | undefined;
|
|
autoPipeliningIgnoredCommands?: string[] | undefined;
|
|
scripts?: Record<string, {
|
|
lua: string;
|
|
numberOfKeys?: number;
|
|
readOnly?: boolean;
|
|
}> | undefined;
|
|
himportFieldsets?: readonly HimportFieldset[] | undefined;
|
|
}
|
|
|
|
type ClusterOptionsWithReplyMapping<Mapping extends ReplyMappingMode> = ClusterOptions & {
|
|
redisOptions?: ClusterOptions["redisOptions"] & {
|
|
replyMapping?: Mapping;
|
|
};
|
|
};
|
|
|
|
type ClusterStatus = "close" | "connect" | "connecting" | "disconnecting" | "end" | "ready" | "reconnecting" | "wait";
|
|
|
|
declare class Command implements Respondable {
|
|
#private;
|
|
name: string;
|
|
static FLAGS: {
|
|
[key in keyof CommandNameFlags]: CommandNameFlags[key];
|
|
};
|
|
static checkFlag<T extends keyof CommandNameFlags>(flagName: T, commandName: string): commandName is CommandNameFlags[T][number];
|
|
static setArgumentTransformer(name: string, func: ArgumentTransformer): void;
|
|
static setReplyTransformer(name: string, func: ReplyTransformer): void;
|
|
ignore?: boolean;
|
|
isReadOnly?: boolean;
|
|
args: CommandParameter[];
|
|
inTransaction: boolean;
|
|
pipelineIndex?: number;
|
|
isTraced: boolean;
|
|
isResolved: boolean;
|
|
isSettled: boolean;
|
|
reject: (err: Error) => void;
|
|
resolve: (result: any) => void;
|
|
promise: Promise<any>;
|
|
constructor(name: string, args?: Array<ArgumentType>, options?: CommandOptions, callback?: Callback);
|
|
getSlot(): number;
|
|
getKeys(): Array<string | Buffer>;
|
|
setReplyContext(context: ReplyContext | null | undefined): void;
|
|
toWritable(_socket: object): string | Buffer;
|
|
stringifyArguments(): void;
|
|
transformReply(result: Buffer | Buffer[]): string | string[] | Buffer | Buffer[];
|
|
setTimeout(ms: number): void;
|
|
setBlockingTimeout(ms: number): void;
|
|
extractBlockingTimeout(): number | null | undefined;
|
|
}
|
|
|
|
interface CommandItem {
|
|
command: Respondable;
|
|
stream: WriteableStream;
|
|
select: number;
|
|
}
|
|
|
|
interface CommandNameFlags {
|
|
VALID_IN_SUBSCRIBER_MODE: [
|
|
"subscribe",
|
|
"psubscribe",
|
|
"unsubscribe",
|
|
"punsubscribe",
|
|
"ssubscribe",
|
|
"sunsubscribe",
|
|
"ping",
|
|
"quit"
|
|
];
|
|
VALID_IN_MONITOR_MODE: [
|
|
"monitor",
|
|
"auth"
|
|
];
|
|
ENTER_SUBSCRIBER_MODE: [
|
|
"subscribe",
|
|
"psubscribe",
|
|
"ssubscribe"
|
|
];
|
|
EXIT_SUBSCRIBER_MODE: [
|
|
"unsubscribe",
|
|
"punsubscribe",
|
|
"sunsubscribe"
|
|
];
|
|
WILL_DISCONNECT: [
|
|
"quit"
|
|
];
|
|
HANDSHAKE_COMMANDS: [
|
|
"auth",
|
|
"hello",
|
|
"select",
|
|
"client",
|
|
"readonly",
|
|
"info"
|
|
];
|
|
IGNORE_RECONNECT_ON_ERROR: [
|
|
"client"
|
|
];
|
|
BLOCKING_COMMANDS: [
|
|
"blpop",
|
|
"brpop",
|
|
"brpoplpush",
|
|
"blmove",
|
|
"blmovem",
|
|
"bzpopmin",
|
|
"bzpopmax",
|
|
"bzmpop",
|
|
"blmpop",
|
|
"xread",
|
|
"xreadgroup"
|
|
];
|
|
LAST_ARG_TIMEOUT_COMMANDS: [
|
|
"blpop",
|
|
"brpop",
|
|
"brpoplpush",
|
|
"blmove",
|
|
"bzpopmin",
|
|
"bzpopmax"
|
|
];
|
|
FIRST_ARG_TIMEOUT_COMMANDS: [
|
|
"bzmpop",
|
|
"blmpop"
|
|
];
|
|
BLOCK_OPTION_COMMANDS: [
|
|
"xread",
|
|
"xreadgroup"
|
|
];
|
|
}
|
|
|
|
interface CommandOptions {
|
|
replyEncoding?: BufferEncoding | null;
|
|
errorStack?: Error;
|
|
keyPrefix?: string;
|
|
readOnly?: boolean;
|
|
}
|
|
|
|
type CommandParameter = string | Buffer | number | any[];
|
|
|
|
declare class Commander<Context extends ClientContext = {
|
|
type: "default";
|
|
}> {
|
|
options: CommanderOptions;
|
|
scriptsSet: {};
|
|
addedBuiltinSet: Set<string>;
|
|
getBuiltinCommands(): string[];
|
|
createBuiltinCommand(commandName: string): {
|
|
string: any;
|
|
buffer: any;
|
|
};
|
|
addBuiltinCommand(commandName: string): void;
|
|
defineCommand(name: string, definition: {
|
|
lua: string;
|
|
numberOfKeys?: number;
|
|
readOnly?: boolean;
|
|
}): void;
|
|
sendCommand(command: Command, stream?: WriteableStream, node?: unknown): unknown;
|
|
}
|
|
|
|
interface Commander<Context> extends RedisCommander<Context> {
|
|
}
|
|
|
|
interface CommanderOptions {
|
|
keyPrefix?: string | undefined;
|
|
showFriendlyErrorStack?: boolean | undefined;
|
|
}
|
|
|
|
interface CommonRedisOptions extends CommanderOptions {
|
|
Connector?: ConnectorConstructor | undefined;
|
|
retryStrategy?: RetryStrategy;
|
|
commandTimeout?: number | undefined;
|
|
blockingTimeout?: number | undefined;
|
|
blockingTimeoutGrace?: number | undefined;
|
|
socketTimeout?: number | undefined;
|
|
keepAlive?: number | undefined;
|
|
noDelay?: boolean | undefined;
|
|
connectionName?: string | undefined;
|
|
disableClientInfo?: boolean | undefined;
|
|
clientInfoTag?: string | undefined;
|
|
username?: string | undefined;
|
|
password?: string | undefined;
|
|
db?: number | undefined;
|
|
autoResubscribe?: boolean | undefined;
|
|
autoResendUnfulfilledCommands?: boolean | undefined;
|
|
reconnectOnError?: ReconnectOnError | null | undefined;
|
|
readOnly?: boolean | undefined;
|
|
stringNumbers?: boolean | undefined;
|
|
protocol?: ProtocolVersion | undefined;
|
|
replyMapping?: ReplyMappingMode | undefined;
|
|
connectTimeout?: number | undefined;
|
|
monitor?: boolean | undefined;
|
|
maxRetriesPerRequest?: number | null | undefined;
|
|
maxLoadingRetryTime?: number | undefined;
|
|
enableAutoPipelining?: boolean | undefined;
|
|
autoPipeliningIgnoredCommands?: string[] | undefined;
|
|
offlineQueue?: boolean | undefined;
|
|
commandQueue?: boolean | undefined;
|
|
enableOfflineQueue?: boolean | undefined;
|
|
enableReadyCheck?: boolean | undefined;
|
|
lazyConnect?: boolean | undefined;
|
|
scripts?: Record<string, {
|
|
lua: string;
|
|
numberOfKeys?: number | undefined;
|
|
readOnly?: boolean | undefined;
|
|
}> | undefined;
|
|
himportFieldsets?: readonly HimportFieldset[] | undefined;
|
|
}
|
|
|
|
interface Condition {
|
|
select: number;
|
|
auth?: string | [
|
|
string,
|
|
string
|
|
];
|
|
subscriber: false | SubscriptionSet;
|
|
protocol: ProtocolVersion;
|
|
replyMapping: ReplyMappingMode;
|
|
handshake: boolean;
|
|
}
|
|
|
|
interface ConnectorConstructor {
|
|
new (options: unknown): AbstractConnector;
|
|
}
|
|
|
|
type CreateResumableAssistantStreamResponseOptions = {
|
|
readonly context: ResumableStreamContext;
|
|
readonly streamId: string;
|
|
readonly callback: (controller: AssistantStreamController) => PromiseLike<void> | void;
|
|
readonly encoder?: () => AssistantStreamEncoder;
|
|
readonly headers?: HeadersInit;
|
|
};
|
|
|
|
type CreateResumeAssistantStreamResponseOptions = {
|
|
readonly context: ResumableStreamContext;
|
|
readonly streamId: string;
|
|
readonly encoder?: () => AssistantStreamEncoder;
|
|
readonly headers?: HeadersInit;
|
|
readonly missingResponse?: () => Response;
|
|
};
|
|
|
|
type DNSLookupFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void) => void;
|
|
|
|
type DNSResolveSrvFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void) => void;
|
|
|
|
interface DataHandledable extends EventEmitter {
|
|
stream: NetStream;
|
|
status: string;
|
|
condition: Condition | null;
|
|
commandQueue: Deque<CommandItem>;
|
|
disconnect(reconnect: boolean): void;
|
|
recoverFromFatalError(commandError: Error, err: Error, options: FlushQueueOptions): void;
|
|
handleReconnection(err: Error, item: CommandItem): void;
|
|
}
|
|
|
|
type DataPart = {
|
|
type: "data";
|
|
name: string;
|
|
data: ReadonlyJSONValue;
|
|
parentId?: string;
|
|
};
|
|
|
|
declare class DataStreamDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, AssistantStreamChunk> {
|
|
constructor(options?: DataStreamOptions);
|
|
}
|
|
|
|
declare class DataStreamEncoder extends PipeableTransformStream<AssistantStreamChunk, Uint8Array<ArrayBuffer>> implements AssistantStreamEncoder {
|
|
headers: Headers;
|
|
constructor();
|
|
}
|
|
|
|
type DataStreamOptions = {
|
|
strict?: boolean | undefined;
|
|
};
|
|
|
|
type DeepPartial<T> = T extends readonly any[] ? readonly DeepPartial<T[number]>[] : T extends {
|
|
[key: string]: any;
|
|
} ? {
|
|
readonly [K in keyof T]?: DeepPartial<T[K]>;
|
|
} : T;
|
|
|
|
type DelSet = CommandNameFlags["EXIT_SUBSCRIBER_MODE"][number];
|
|
|
|
type ErrorEmitter = (type: string, err: Error) => void;
|
|
|
|
type FieldState = "complete" | "partial";
|
|
|
|
type FilePart = {
|
|
type: "file";
|
|
data: string;
|
|
mimeType: string;
|
|
parentId?: string;
|
|
};
|
|
|
|
type FinishReason = "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls" | "unknown";
|
|
|
|
type FlushQueueOptions = {
|
|
offlineQueue?: boolean;
|
|
commandQueue?: boolean;
|
|
};
|
|
|
|
type FrontendTool<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolBase<TArgs, TResult> & {
|
|
type: "frontend";
|
|
description?: string | undefined;
|
|
parameters: StandardSchemaV1<TArgs> | JSONSchema7;
|
|
disabled?: boolean;
|
|
execute?: ToolExecuteFunction<TArgs, TResult>;
|
|
toModelOutput?: ToolModelOutputFunction<TArgs, TResult>;
|
|
experimental_onSchemaValidationError?: OnSchemaValidationErrorFunction<TResult>;
|
|
providerOptions?: ProviderOptions;
|
|
};
|
|
|
|
type GenericAssistantMessage = {
|
|
role: "assistant";
|
|
content: (GenericTextPart | GenericToolCallPart)[];
|
|
};
|
|
|
|
type GenericFilePart = {
|
|
type: "file";
|
|
data: string | URL;
|
|
mediaType: string;
|
|
filename?: string;
|
|
};
|
|
|
|
type GenericMessage = GenericSystemMessage | GenericUserMessage | GenericAssistantMessage | GenericToolMessage;
|
|
|
|
type GenericSystemMessage = {
|
|
role: "system";
|
|
content: string;
|
|
};
|
|
|
|
type GenericTextPart = {
|
|
type: "text";
|
|
text: string;
|
|
};
|
|
|
|
type GenericToolCallPart = {
|
|
type: "tool-call";
|
|
toolCallId: string;
|
|
toolName: string;
|
|
args: Record<string, unknown>;
|
|
};
|
|
|
|
type GenericToolMessage = {
|
|
role: "tool";
|
|
content: GenericToolResultPart[];
|
|
};
|
|
|
|
type GenericToolResultPart = {
|
|
type: "tool-result";
|
|
toolCallId: string;
|
|
toolName: string;
|
|
result: unknown;
|
|
isError?: boolean;
|
|
};
|
|
|
|
type GenericUserMessage = {
|
|
role: "user";
|
|
content: (GenericTextPart | GenericFilePart)[];
|
|
};
|
|
|
|
type GorpStreamChunk = {
|
|
readonly snapshot: ReadonlyJSONValue;
|
|
readonly operations: readonly GorpStreamOperation[];
|
|
};
|
|
|
|
declare class GorpStreamDeltaTracker {
|
|
#private;
|
|
constructor(initialValue?: ReadonlyJSONValue);
|
|
get state(): ReadonlyJSONValue;
|
|
append(operations: readonly GorpStreamOperation[]): void;
|
|
isChangedAt(path: readonly string[]): boolean;
|
|
getChangedKeys(path: readonly string[]): string[];
|
|
}
|
|
|
|
type GorpStreamOperation = AssistantTransportStateOperation;
|
|
|
|
declare class GorpStreamResponse extends Response {
|
|
constructor(body: ReadableStream<GorpStreamChunk>);
|
|
}
|
|
|
|
interface HimportFieldset {
|
|
readonly name: string | Buffer;
|
|
readonly fields: readonly (string | Buffer)[];
|
|
}
|
|
|
|
type HumanTool<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolBase<TArgs, TResult> & {
|
|
type: "human";
|
|
description?: string | undefined;
|
|
parameters: StandardSchemaV1<TArgs> | JSONSchema7;
|
|
disabled?: boolean;
|
|
display?: "standalone";
|
|
execute?: undefined;
|
|
toModelOutput?: undefined;
|
|
experimental_onSchemaValidationError?: undefined;
|
|
providerOptions?: ProviderOptions;
|
|
};
|
|
|
|
type InMemoryResumableStreamStoreOptions = {
|
|
readonly defaultTtlMs?: number;
|
|
readonly now?: () => number;
|
|
readonly maxChunkBytes?: number;
|
|
readonly maxEntriesPerStream?: number;
|
|
readonly maxStreams?: number;
|
|
readonly gcIntervalMs?: number;
|
|
};
|
|
|
|
type IoRedisLike = Redis | Cluster;
|
|
|
|
type IpcOptions = Pick<IpcNetConnectOpts, "path">;
|
|
|
|
interface JSONSchema7 {
|
|
$id?: string | undefined;
|
|
$ref?: string | undefined;
|
|
$schema?: JSONSchema7Version | undefined;
|
|
$comment?: string | undefined;
|
|
$defs?: {
|
|
[key: string]: JSONSchema7Definition;
|
|
} | undefined;
|
|
type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
|
|
enum?: JSONSchema7Type[] | undefined;
|
|
const?: JSONSchema7Type | undefined;
|
|
multipleOf?: number | undefined;
|
|
maximum?: number | undefined;
|
|
exclusiveMaximum?: number | undefined;
|
|
minimum?: number | undefined;
|
|
exclusiveMinimum?: number | undefined;
|
|
maxLength?: number | undefined;
|
|
minLength?: number | undefined;
|
|
pattern?: string | undefined;
|
|
items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
|
|
additionalItems?: JSONSchema7Definition | undefined;
|
|
maxItems?: number | undefined;
|
|
minItems?: number | undefined;
|
|
uniqueItems?: boolean | undefined;
|
|
contains?: JSONSchema7Definition | undefined;
|
|
maxProperties?: number | undefined;
|
|
minProperties?: number | undefined;
|
|
required?: string[] | undefined;
|
|
properties?: {
|
|
[key: string]: JSONSchema7Definition;
|
|
} | undefined;
|
|
patternProperties?: {
|
|
[key: string]: JSONSchema7Definition;
|
|
} | undefined;
|
|
additionalProperties?: JSONSchema7Definition | undefined;
|
|
dependencies?: {
|
|
[key: string]: JSONSchema7Definition | string[];
|
|
} | undefined;
|
|
propertyNames?: JSONSchema7Definition | undefined;
|
|
if?: JSONSchema7Definition | undefined;
|
|
then?: JSONSchema7Definition | undefined;
|
|
else?: JSONSchema7Definition | undefined;
|
|
allOf?: JSONSchema7Definition[] | undefined;
|
|
anyOf?: JSONSchema7Definition[] | undefined;
|
|
oneOf?: JSONSchema7Definition[] | undefined;
|
|
not?: JSONSchema7Definition | undefined;
|
|
format?: string | undefined;
|
|
contentMediaType?: string | undefined;
|
|
contentEncoding?: string | undefined;
|
|
definitions?: {
|
|
[key: string]: JSONSchema7Definition;
|
|
} | undefined;
|
|
title?: string | undefined;
|
|
description?: string | undefined;
|
|
default?: JSONSchema7Type | undefined;
|
|
readOnly?: boolean | undefined;
|
|
writeOnly?: boolean | undefined;
|
|
examples?: JSONSchema7Type | undefined;
|
|
}
|
|
|
|
interface JSONSchema7Array extends Array<JSONSchema7Type> {
|
|
}
|
|
|
|
type JSONSchema7Definition = JSONSchema7 | boolean;
|
|
|
|
interface JSONSchema7Object {
|
|
[key: string]: JSONSchema7Type;
|
|
}
|
|
|
|
type JSONSchema7Type = string | number | boolean | JSONSchema7Object | JSONSchema7Array | null;
|
|
|
|
type JSONSchema7TypeName = "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
|
|
|
|
type JSONSchema7Version = string;
|
|
|
|
type McpServerConfig = {
|
|
type: "http" | "sse";
|
|
url: string;
|
|
headers?: Record<string, string>;
|
|
redirect?: "error" | "follow";
|
|
connectionTimeout?: number | undefined;
|
|
} | {
|
|
type: "stdio";
|
|
command: string;
|
|
args?: readonly string[];
|
|
env?: Record<string, string>;
|
|
cwd?: string;
|
|
connectionTimeout?: number | undefined;
|
|
};
|
|
|
|
type McpTool = ToolBase<Record<string, unknown>, unknown> & {
|
|
type: "mcp";
|
|
server: McpServerConfig;
|
|
description?: undefined;
|
|
parameters?: undefined;
|
|
disabled?: boolean;
|
|
execute?: undefined;
|
|
toModelOutput?: undefined;
|
|
experimental_onSchemaValidationError?: undefined;
|
|
providerOptions?: undefined;
|
|
};
|
|
|
|
type MessagePartLike = {
|
|
type: string;
|
|
text?: string;
|
|
image?: string;
|
|
data?: string;
|
|
mimeType?: string;
|
|
filename?: string;
|
|
toolCallId?: string;
|
|
toolName?: string;
|
|
args?: Record<string, unknown>;
|
|
state?: string;
|
|
result?: unknown;
|
|
isError?: boolean;
|
|
approval?: {
|
|
approved?: boolean;
|
|
resolution?: string;
|
|
[key: string]: unknown;
|
|
};
|
|
interrupt?: unknown;
|
|
};
|
|
|
|
type NatMap = {
|
|
[key: string]: {
|
|
host: string;
|
|
port: number;
|
|
};
|
|
} | NatMapFunction;
|
|
|
|
type NatMapFunction = (key: string) => {
|
|
host: string;
|
|
port: number;
|
|
} | null;
|
|
|
|
type NetStream = Socket | TLSSocket;
|
|
|
|
type NodeKey = string;
|
|
|
|
type NodeRedisFields = Record<string, string | Buffer>;
|
|
|
|
interface NodeRedisLike {
|
|
set(key: string, value: string, options: {
|
|
NX: true;
|
|
EX: number;
|
|
}): Promise<string | null>;
|
|
set(key: string, value: string, options: {
|
|
EX: number;
|
|
}): Promise<string | null>;
|
|
get(key: string): Promise<string | null>;
|
|
expire(key: string, seconds: number): Promise<unknown>;
|
|
exists(key: string): Promise<number>;
|
|
del(keys: string | string[]): Promise<unknown>;
|
|
xAdd(key: string, id: string, fields: NodeRedisFields): Promise<string>;
|
|
sendCommand<T = unknown>(args: ReadonlyArray<string | Buffer>, options?: {
|
|
typeMapping?: Record<number, unknown>;
|
|
}): Promise<T>;
|
|
multi(): NodeRedisMultiCommand;
|
|
}
|
|
|
|
interface NodeRedisMultiCommand {
|
|
xAdd(key: string, id: string, fields: NodeRedisFields): NodeRedisMultiCommand;
|
|
expire(key: string, seconds: number): NodeRedisMultiCommand;
|
|
set(key: string, value: string, options: {
|
|
EX: number;
|
|
}): NodeRedisMultiCommand;
|
|
execAsPipeline(): Promise<unknown>;
|
|
exec(): Promise<unknown>;
|
|
}
|
|
|
|
type NodeRole = "all" | "master" | "slave";
|
|
|
|
type ObjectKey<T> = keyof T & (string | number);
|
|
|
|
type ObjectStreamChunk = GorpStreamChunk;
|
|
|
|
declare const ObjectStreamResponse: typeof GorpStreamResponse;
|
|
|
|
type ObjectStreamResponse = GorpStreamResponse;
|
|
|
|
type OnSchemaValidationErrorFunction<TResult> = ToolExecuteFunction<unknown, TResult>;
|
|
|
|
interface Options extends ReadableOptions {
|
|
key?: string;
|
|
match?: string;
|
|
type?: string;
|
|
command: string;
|
|
redis: any;
|
|
count?: string | number;
|
|
noValues?: boolean;
|
|
}
|
|
|
|
declare const PARTIAL_JSON_OBJECT_META_SYMBOL: unique symbol;
|
|
|
|
type PartInit = {
|
|
readonly type: "text";
|
|
readonly parentId?: string;
|
|
} | {
|
|
readonly type: "reasoning";
|
|
readonly unstable_summary?: string;
|
|
readonly parentId?: string;
|
|
} | {
|
|
readonly type: "tool-call";
|
|
readonly toolCallId: string;
|
|
readonly toolName: string;
|
|
readonly parentId?: string;
|
|
} | {
|
|
readonly type: "source";
|
|
readonly sourceType: "url";
|
|
readonly id: string;
|
|
readonly url: string;
|
|
readonly title?: string;
|
|
readonly parentId?: string;
|
|
} | {
|
|
readonly type: "file";
|
|
readonly data: string;
|
|
readonly mimeType: string;
|
|
readonly parentId?: string;
|
|
} | {
|
|
readonly type: "data";
|
|
readonly name: string;
|
|
readonly data: ReadonlyJSONValue;
|
|
readonly parentId?: string;
|
|
};
|
|
|
|
type PartialJsonObjectMeta = {
|
|
state: "complete" | "partial";
|
|
partialPath: string[];
|
|
};
|
|
|
|
declare class PipeableTransformStream<I, O> extends TransformStream<I, O> {
|
|
constructor(transform: (readable: ReadableStream<I>) => ReadableStream<O>);
|
|
}
|
|
|
|
type PipelineCommand = {
|
|
readonly type: "xAdd";
|
|
readonly key: string;
|
|
readonly fields: Record<string, string | Uint8Array>;
|
|
} | {
|
|
readonly type: "expire";
|
|
readonly key: string;
|
|
readonly ttlSec: number;
|
|
} | {
|
|
readonly type: "set";
|
|
readonly key: string;
|
|
readonly value: string;
|
|
readonly ttlSec: number;
|
|
};
|
|
|
|
interface PipelineWriteableStream {
|
|
isPipeline: true;
|
|
write(data: string | Buffer): unknown;
|
|
destination: {
|
|
redis: {
|
|
stream: NetStream;
|
|
};
|
|
};
|
|
}
|
|
|
|
declare class PlainTextDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, AssistantStreamChunk> {
|
|
constructor();
|
|
}
|
|
|
|
declare class PlainTextEncoder extends PipeableTransformStream<AssistantStreamChunk, Uint8Array<ArrayBuffer>> implements AssistantStreamEncoder {
|
|
headers: Headers;
|
|
constructor();
|
|
}
|
|
|
|
type PreferredSlaves = ((slaves: AddressFromResponse[]) => AddressFromResponse | null) | Array<{
|
|
port: string;
|
|
ip: string;
|
|
prio?: number | undefined;
|
|
}> | {
|
|
port: string;
|
|
ip: string;
|
|
prio?: number | undefined;
|
|
};
|
|
|
|
type ProtocolVersion = 2 | 3;
|
|
|
|
type ProviderOptions = Record<string, Record<string, unknown>>;
|
|
|
|
type ProviderTool<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = ToolBase<TArgs, TResult> & {
|
|
type: "provider";
|
|
providerId: `${string}.${string}`;
|
|
parameters?: StandardSchemaV1<TArgs> | JSONSchema7 | undefined;
|
|
args: Record<string, unknown>;
|
|
supportsDeferredResults?: boolean;
|
|
description?: undefined;
|
|
disabled?: boolean;
|
|
execute?: undefined;
|
|
toModelOutput?: undefined;
|
|
experimental_onSchemaValidationError?: undefined;
|
|
providerOptions?: ProviderOptions;
|
|
};
|
|
|
|
declare const RESUMABLE_STREAM_ID_HEADER = "x-resumable-stream-id";
|
|
|
|
type ReadonlyJSONArray = readonly ReadonlyJSONValue[];
|
|
|
|
type ReadonlyJSONObject = {
|
|
readonly [key: string]: ReadonlyJSONValue;
|
|
};
|
|
|
|
type ReadonlyJSONValue = null | string | number | boolean | ReadonlyJSONObject | ReadonlyJSONArray;
|
|
|
|
type ReasoningPart = {
|
|
type: "reasoning";
|
|
text: string;
|
|
status: TextStatus;
|
|
unstable_summary?: string;
|
|
parentId?: string;
|
|
};
|
|
|
|
type ReasoningPartInit = {
|
|
unstable_summary?: string;
|
|
};
|
|
|
|
type ReconnectOnError = (err: Error) => boolean | 1 | 2;
|
|
|
|
declare class Redis<ReplyMapping extends ReplyMappingMode = "legacy"> extends Commander<{
|
|
type: "default";
|
|
mapping: ReplyMapping extends "resp3" ? "resp3" : "resp2";
|
|
}> implements DataHandledable {
|
|
#private;
|
|
static Cluster: typeof Cluster;
|
|
static Command: typeof Command;
|
|
static createClient(...args: ConstructorParameters<typeof Redis>): Redis;
|
|
options: RedisOptions;
|
|
status: RedisStatus;
|
|
stream: NetStream;
|
|
isCluster: boolean;
|
|
condition: Condition | null;
|
|
commandQueue: Deque<CommandItem>;
|
|
constructor(port: number, host: string, options: RedisOptions & {
|
|
replyMapping?: ReplyMapping;
|
|
});
|
|
constructor(path: string, options: RedisOptions & {
|
|
replyMapping?: ReplyMapping;
|
|
});
|
|
constructor(port: number, options: RedisOptions & {
|
|
replyMapping?: ReplyMapping;
|
|
});
|
|
constructor(port: number, host: string);
|
|
constructor(options: RedisOptions & {
|
|
replyMapping?: ReplyMapping;
|
|
});
|
|
constructor(port: number);
|
|
constructor(path: string);
|
|
constructor();
|
|
get autoPipelineQueueSize(): number;
|
|
connect(callback?: Callback<void>): Promise<void>;
|
|
disconnect(reconnect?: boolean): void;
|
|
end(): void;
|
|
duplicate<Override extends Partial<RedisOptions> | undefined = undefined>(override?: Override): Redis<ReplyMappingFromOptions<ReplyMapping, Override>>;
|
|
get mode(): "monitor" | "normal" | "subscriber";
|
|
monitor(callback?: Callback<Redis>): Promise<Redis>;
|
|
sendCommand(command: Command, stream?: WriteableStream): unknown;
|
|
scanStream(options?: ScanStreamOptions): ScanStream;
|
|
scanBufferStream(options?: ScanStreamOptions): ScanStream;
|
|
sscanStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
sscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
hscanStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
hscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
zscanStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
zscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
|
|
silentEmit(eventName: string, arg?: unknown): boolean;
|
|
recoverFromFatalError(_commandError: Error, err: Error, options: FlushQueueOptions): void;
|
|
handleReconnection(err: Error, item: CommandItem): void;
|
|
_getServerAddress(): {
|
|
address: string;
|
|
port: number | undefined;
|
|
};
|
|
_buildBatchContext(batchSize: number): BatchOperationContext;
|
|
}
|
|
|
|
interface Redis<ReplyMapping extends "legacy" | "resp3" = "legacy"> extends EventEmitter {
|
|
on(event: "message", cb: (channel: string, message: string) => void): this;
|
|
once(event: "message", cb: (channel: string, message: string) => void): this;
|
|
on(event: "messageBuffer", cb: (channel: Buffer, message: Buffer) => void): this;
|
|
once(event: "messageBuffer", cb: (channel: Buffer, message: Buffer) => void): this;
|
|
on(event: "pmessage", cb: (pattern: string, channel: string, message: string) => void): this;
|
|
once(event: "pmessage", cb: (pattern: string, channel: string, message: string) => void): this;
|
|
on(event: "pmessageBuffer", cb: (pattern: string, channel: Buffer, message: Buffer) => void): this;
|
|
once(event: "pmessageBuffer", cb: (pattern: string, channel: Buffer, message: Buffer) => void): this;
|
|
on(event: "error", cb: (error: Error) => void): this;
|
|
once(event: "error", cb: (error: Error) => void): this;
|
|
on(event: RedisStatus, cb: () => void): this;
|
|
once(event: RedisStatus, cb: () => void): this;
|
|
on(event: string | symbol, listener: (...args: any[]) => void): this;
|
|
once(event: string | symbol, listener: (...args: any[]) => void): this;
|
|
}
|
|
|
|
interface Redis<ReplyMapping extends "legacy" | "resp3" = "legacy"> extends Transaction<ReplyMapping extends "resp3" ? "resp3" : "resp2"> {
|
|
}
|
|
|
|
interface RedisCommander<Context extends ClientContext = {
|
|
type: "default";
|
|
}> {
|
|
call(command: string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
call(command: string, args: (string | Buffer | number)[], callback?: Callback<unknown>): Result<unknown, Context>;
|
|
call(...args: [
|
|
command: string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
call(...args: [
|
|
command: string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
callBuffer(command: string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
callBuffer(command: string, args: (string | Buffer | number)[], callback?: Callback<unknown>): Result<unknown, Context>;
|
|
callBuffer(...args: [
|
|
command: string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
callBuffer(...args: [
|
|
command: string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
acl(subcommand: 'CAT', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
acl(subcommand: 'CAT', category: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
acl(...args: [
|
|
subcommand: 'DELUSER',
|
|
...usernames: (string | Buffer)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
acl(...args: [
|
|
subcommand: 'DELUSER',
|
|
...usernames: (string | Buffer)[]
|
|
]): Result<number, Context>;
|
|
acl(subcommand: 'DRYRUN', username: string | Buffer, command: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
aclBuffer(subcommand: 'DRYRUN', username: string | Buffer, command: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
acl(...args: [
|
|
subcommand: 'DRYRUN',
|
|
username: string | Buffer,
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<string>
|
|
]): Result<string, Context>;
|
|
aclBuffer(...args: [
|
|
subcommand: 'DRYRUN',
|
|
username: string | Buffer,
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<Buffer>
|
|
]): Result<Buffer, Context>;
|
|
acl(...args: [
|
|
subcommand: 'DRYRUN',
|
|
username: string | Buffer,
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<string, Context>;
|
|
aclBuffer(...args: [
|
|
subcommand: 'DRYRUN',
|
|
username: string | Buffer,
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<Buffer, Context>;
|
|
acl(subcommand: 'GENPASS', callback?: Callback<string>): Result<string, Context>;
|
|
aclBuffer(subcommand: 'GENPASS', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
acl(subcommand: 'GENPASS', bits: number | string, callback?: Callback<string>): Result<string, Context>;
|
|
aclBuffer(subcommand: 'GENPASS', bits: number | string, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
acl(subcommand: 'GETUSER', username: string | Buffer, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
aclBuffer(subcommand: 'GETUSER', username: string | Buffer, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
acl(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
acl(subcommand: 'LIST', callback?: Callback<string[]>): Result<string[], Context>;
|
|
aclBuffer(subcommand: 'LIST', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
acl(subcommand: 'LOAD', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
acl(subcommand: 'LOG', reset: 'RESET', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
acl(subcommand: 'LOG', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
acl(subcommand: 'LOG', count: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
acl(subcommand: 'SAVE', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
acl(subcommand: 'SETUSER', username: string | Buffer, callback?: Callback<"OK">): Result<"OK", Context>;
|
|
acl(...args: [
|
|
subcommand: 'SETUSER',
|
|
username: string | Buffer,
|
|
...rules: (string | Buffer)[],
|
|
callback: Callback<"OK">
|
|
]): Result<"OK", Context>;
|
|
acl(...args: [
|
|
subcommand: 'SETUSER',
|
|
username: string | Buffer,
|
|
...rules: (string | Buffer)[]
|
|
]): Result<"OK", Context>;
|
|
acl(subcommand: 'USERS', callback?: Callback<string[]>): Result<string[], Context>;
|
|
aclBuffer(subcommand: 'USERS', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
acl(subcommand: 'WHOAMI', callback?: Callback<string>): Result<string, Context>;
|
|
aclBuffer(subcommand: 'WHOAMI', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
append(key: RedisKey, value: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
arcount(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
ardel(...args: [
|
|
key: RedisKey,
|
|
...indices: (number | string)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
ardel(...args: [
|
|
key: RedisKey,
|
|
...indices: (number | string)[]
|
|
]): Result<number, Context>;
|
|
ardelrange(...args: [
|
|
key: RedisKey,
|
|
...ranges: (string | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
ardelrange(...args: [
|
|
key: RedisKey,
|
|
...ranges: (string | number)[]
|
|
]): Result<number, Context>;
|
|
arget(key: RedisKey, index: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
argetBuffer(key: RedisKey, index: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
argetrange(key: RedisKey, start: number | string, end: number | string, callback?: Callback<(string | null)[]>): Result<(string | null)[], Context>;
|
|
argetrangeBuffer(key: RedisKey, start: number | string, end: number | string, callback?: Callback<(Buffer | null)[]>): Result<(Buffer | null)[], Context>;
|
|
argrep(key: RedisKey, start: number | string, end: number | string, predicate: 'EXACT' | 'GLOB' | 'MATCH' | 'RE', value: RedisValue, callback: Callback<number[]>): Result<number[], Context>;
|
|
argrep(...args: [
|
|
key: RedisKey,
|
|
start: number | string,
|
|
end: number | string,
|
|
predicate: 'EXACT' | 'GLOB' | 'MATCH' | 'RE',
|
|
value: RedisValue,
|
|
...args: RedisValue[],
|
|
callback: Callback<number[] | Array<[
|
|
index: number,
|
|
value: string
|
|
]>>
|
|
]): Result<number[] | Array<[
|
|
index: number,
|
|
value: string
|
|
]>, Context>;
|
|
argrep<T extends RedisValue[]>(...args: [
|
|
key: RedisKey,
|
|
start: number | string,
|
|
end: number | string,
|
|
predicate: 'EXACT' | 'GLOB' | 'MATCH' | 'RE',
|
|
value: RedisValue,
|
|
...args: T
|
|
]): Result<'WITHVALUES' extends T[number] ? Array<[
|
|
index: number,
|
|
value: string
|
|
]> : number[], Context>;
|
|
argrepBuffer(key: RedisKey, start: number | string, end: number | string, predicate: 'EXACT' | 'GLOB' | 'MATCH' | 'RE', value: RedisValue, callback: Callback<number[]>): Result<number[], Context>;
|
|
argrepBuffer(...args: [
|
|
key: RedisKey,
|
|
start: number | string,
|
|
end: number | string,
|
|
predicate: 'EXACT' | 'GLOB' | 'MATCH' | 'RE',
|
|
value: RedisValue,
|
|
...args: RedisValue[],
|
|
callback: Callback<number[] | Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]>>
|
|
]): Result<number[] | Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]>, Context>;
|
|
argrepBuffer<T extends RedisValue[]>(...args: [
|
|
key: RedisKey,
|
|
start: number | string,
|
|
end: number | string,
|
|
predicate: 'EXACT' | 'GLOB' | 'MATCH' | 'RE',
|
|
value: RedisValue,
|
|
...args: T
|
|
]): Result<'WITHVALUES' extends T[number] ? Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]> : number[], Context>;
|
|
arinfo(key: RedisKey, full: 'FULL', callback?: Callback<(string | number)[]>): Result<(string | number)[], Context>;
|
|
arinfoBuffer(key: RedisKey, full: 'FULL', callback?: Callback<(Buffer | number)[]>): Result<(Buffer | number)[], Context>;
|
|
arinfo(key: RedisKey, callback?: Callback<(string | number)[]>): Result<(string | number)[], Context>;
|
|
arinfoBuffer(key: RedisKey, callback?: Callback<(Buffer | number)[]>): Result<(Buffer | number)[], Context>;
|
|
arinsert(...args: [
|
|
key: RedisKey,
|
|
...values: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
arinsert(...args: [
|
|
key: RedisKey,
|
|
...values: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
arlastitems(key: RedisKey, count: number | string, rev: 'REV', callback?: Callback<(string | null)[]>): Result<(string | null)[], Context>;
|
|
arlastitemsBuffer(key: RedisKey, count: number | string, rev: 'REV', callback?: Callback<(Buffer | null)[]>): Result<(Buffer | null)[], Context>;
|
|
arlastitems(key: RedisKey, count: number | string, callback?: Callback<(string | null)[]>): Result<(string | null)[], Context>;
|
|
arlastitemsBuffer(key: RedisKey, count: number | string, callback?: Callback<(Buffer | null)[]>): Result<(Buffer | null)[], Context>;
|
|
arlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
armget(...args: [
|
|
key: RedisKey,
|
|
...indices: (number | string)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
armgetBuffer(...args: [
|
|
key: RedisKey,
|
|
...indices: (number | string)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
armget(...args: [
|
|
key: RedisKey,
|
|
...indices: (number | string)[]
|
|
]): Result<(string | null)[], Context>;
|
|
armgetBuffer(...args: [
|
|
key: RedisKey,
|
|
...indices: (number | string)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
armset(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
armset(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
arnext(key: RedisKey, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, sum: 'SUM', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
aropBuffer(key: RedisKey, start: number | string, end: number | string, sum: 'SUM', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, min: 'MIN', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
aropBuffer(key: RedisKey, start: number | string, end: number | string, min: 'MIN', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, max: 'MAX', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
aropBuffer(key: RedisKey, start: number | string, end: number | string, max: 'MAX', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, and: 'AND', callback?: Callback<number | null>): Result<number | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, or: 'OR', callback?: Callback<number | null>): Result<number | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, xor: 'XOR', callback?: Callback<number | null>): Result<number | null, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, match: 'MATCH', value: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
arop(key: RedisKey, start: number | string, end: number | string, used: 'USED', callback?: Callback<number>): Result<number, Context>;
|
|
arring(...args: [
|
|
key: RedisKey,
|
|
size: number | string,
|
|
...values: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
arring(...args: [
|
|
key: RedisKey,
|
|
size: number | string,
|
|
...values: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
arscan(key: RedisKey, start: number | string, end: number | string, limitToken: 'LIMIT', limit: number | string, callback?: Callback<Array<[
|
|
index: number,
|
|
value: string
|
|
]>>): Result<Array<[
|
|
index: number,
|
|
value: string
|
|
]>, Context>;
|
|
arscanBuffer(key: RedisKey, start: number | string, end: number | string, limitToken: 'LIMIT', limit: number | string, callback?: Callback<Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]>>): Result<Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]>, Context>;
|
|
arscan(key: RedisKey, start: number | string, end: number | string, callback?: Callback<Array<[
|
|
index: number,
|
|
value: string
|
|
]>>): Result<Array<[
|
|
index: number,
|
|
value: string
|
|
]>, Context>;
|
|
arscanBuffer(key: RedisKey, start: number | string, end: number | string, callback?: Callback<Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]>>): Result<Array<[
|
|
index: number,
|
|
value: Buffer
|
|
]>, Context>;
|
|
arseek(key: RedisKey, index: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
arset(...args: [
|
|
key: RedisKey,
|
|
index: number | string,
|
|
...values: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
arset(...args: [
|
|
key: RedisKey,
|
|
index: number | string,
|
|
...values: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
asking(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
auth(password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
auth(username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
bgrewriteaof(callback?: Callback<string>): Result<string, Context>;
|
|
bgrewriteaofBuffer(callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
bgsave(schedule: 'SCHEDULE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
bgsave(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
bitcount(key: RedisKey, start: number | string, end: number | string, byte: 'BYTE', callback?: Callback<number>): Result<number, Context>;
|
|
bitcount(key: RedisKey, start: number | string, end: number | string, bit: 'BIT', callback?: Callback<number>): Result<number, Context>;
|
|
bitcount(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
bitcount(key: RedisKey, start: number | string, end: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
bitfield(key: RedisKey, overflow: 'OVERFLOW', wrap: 'WRAP', setBlockToken: 'SET', encoding: string | Buffer, offset: number | string, value: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, overflow: 'OVERFLOW', wrap: 'WRAP', incrbyBlockToken: 'INCRBY', encoding: string | Buffer, offset: number | string, increment: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, overflow: 'OVERFLOW', sat: 'SAT', setBlockToken: 'SET', encoding: string | Buffer, offset: number | string, value: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, overflow: 'OVERFLOW', sat: 'SAT', incrbyBlockToken: 'INCRBY', encoding: string | Buffer, offset: number | string, increment: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, overflow: 'OVERFLOW', fail: 'FAIL', setBlockToken: 'SET', encoding: string | Buffer, offset: number | string, value: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, overflow: 'OVERFLOW', fail: 'FAIL', incrbyBlockToken: 'INCRBY', encoding: string | Buffer, offset: number | string, increment: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, getBlockToken: 'GET', encoding: string | Buffer, offset: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, setBlockToken: 'SET', encoding: string | Buffer, offset: number | string, value: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, incrbyBlockToken: 'INCRBY', encoding: string | Buffer, offset: number | string, increment: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield(key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
bitfield_ro(...args: [
|
|
key: RedisKey,
|
|
getBlockToken: 'GET',
|
|
...getBlocks: (string | Buffer | number)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
bitfield_ro(...args: [
|
|
key: RedisKey,
|
|
getBlockToken: 'GET',
|
|
...getBlocks: (string | Buffer | number)[]
|
|
]): Result<unknown[], Context>;
|
|
bitfield_ro(key: RedisKey, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
bitop(...args: [
|
|
and: 'AND',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
and: 'AND',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
and: 'AND',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
and: 'AND',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
or: 'OR',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
or: 'OR',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
or: 'OR',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
or: 'OR',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
xor: 'XOR',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
xor: 'XOR',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
xor: 'XOR',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
xor: 'XOR',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
not: 'NOT',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
not: 'NOT',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
not: 'NOT',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
not: 'NOT',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff: 'DIFF',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff: 'DIFF',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff: 'DIFF',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff: 'DIFF',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff1: 'DIFF1',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff1: 'DIFF1',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff1: 'DIFF1',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
diff1: 'DIFF1',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
andor: 'ANDOR',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
andor: 'ANDOR',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
andor: 'ANDOR',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
andor: 'ANDOR',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
one: 'ONE',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
one: 'ONE',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
one: 'ONE',
|
|
destkey: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitop(...args: [
|
|
one: 'ONE',
|
|
destkey: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
bitpos(key: RedisKey, bit: number | string, start: number | string, end: number | string, byte: 'BYTE', callback?: Callback<number>): Result<number, Context>;
|
|
bitpos(key: RedisKey, bit: number | string, start: number | string, end: number | string, bit1: 'BIT', callback?: Callback<number>): Result<number, Context>;
|
|
bitpos(key: RedisKey, bit: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
bitpos(key: RedisKey, bit: number | string, start: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
bitpos(key: RedisKey, bit: number | string, start: number | string, end: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
blmove(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
blmoveBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
blmove(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
blmoveBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
blmove(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
blmoveBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
blmove(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
blmoveBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', timeout: number | string, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', timeout: number | string, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', timeout: number | string, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
blmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', timeout: number | string, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
blmpopBuffer(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
blpop(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
string,
|
|
string
|
|
] | null>
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
blpopBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
Buffer,
|
|
Buffer
|
|
] | null>
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
blpop(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
string,
|
|
string
|
|
] | null>
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
blpopBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
Buffer,
|
|
Buffer
|
|
] | null>
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
blpop(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
blpopBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
blpop(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
blpopBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
brpop(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
string,
|
|
string
|
|
] | null>
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
brpopBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
Buffer,
|
|
Buffer
|
|
] | null>
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
brpop(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
string,
|
|
string
|
|
] | null>
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
brpopBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<[
|
|
Buffer,
|
|
Buffer
|
|
] | null>
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
brpop(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
brpopBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
brpop(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
string,
|
|
string
|
|
] | null, Context>;
|
|
brpopBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<[
|
|
Buffer,
|
|
Buffer
|
|
] | null, Context>;
|
|
brpoplpush(source: RedisKey, destination: RedisKey, timeout: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
brpoplpushBuffer(source: RedisKey, destination: RedisKey, timeout: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN'
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN'
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX'
|
|
]): Result<unknown, Context>;
|
|
bzmpop(...args: [
|
|
timeout: number | string,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX'
|
|
]): Result<unknown, Context>;
|
|
bzpopmax(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopmaxBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmax(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopmaxBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmax(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopmaxBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmax(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopmaxBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmin(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopminBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmin(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopminBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string,
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmin(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopminBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
bzpopmin(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
member: string,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
key: string,
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
bzpopminBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
timeout: number | string
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
key: Buffer,
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
client(subcommand: 'CACHING', yes: 'YES', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
client(subcommand: 'CACHING', no: 'NO', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
client(subcommand: 'GETNAME', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
clientBuffer(subcommand: 'GETNAME', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
client(subcommand: 'GETREDIR', callback?: Callback<number>): Result<number, Context>;
|
|
client(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'ID', callback?: Callback<number>): Result<number, Context>;
|
|
client(subcommand: 'INFO', callback?: Callback<string>): Result<string, Context>;
|
|
clientBuffer(subcommand: 'INFO', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
client(subcommand: 'KILL', type: 'TYPE', normal: 'NORMAL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', type: 'TYPE', master: 'MASTER', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', type: 'TYPE', slave: 'SLAVE', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', type: 'TYPE', replica: 'REPLICA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', type: 'TYPE', pubsub: 'PUBSUB', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', skipme: 'SKIPME', yes: 'YES', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', skipme: 'SKIPME', no: 'NO', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', clientIdToken: 'ID', clientId: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', usernameToken: 'USER', username: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', addrToken: 'ADDR', addr: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', laddrToken: 'LADDR', laddr: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', maxageToken: 'MAXAGE', maxage: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', oldFormat: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
normal: 'NORMAL',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
normal: 'NORMAL',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[]
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
master: 'MASTER',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
master: 'MASTER',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[]
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
replica: 'REPLICA',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
replica: 'REPLICA',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[]
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
pubsub: 'PUBSUB',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
type: 'TYPE',
|
|
pubsub: 'PUBSUB',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[]
|
|
]): Result<unknown, Context>;
|
|
client(subcommand: 'LIST', type: 'TYPE', normal: 'NORMAL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'LIST', type: 'TYPE', master: 'MASTER', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'LIST', type: 'TYPE', replica: 'REPLICA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'LIST', type: 'TYPE', pubsub: 'PUBSUB', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'LIST',
|
|
clientIdToken: 'ID',
|
|
...clientIds: (number | string)[]
|
|
]): Result<unknown, Context>;
|
|
client(subcommand: 'LIST', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'NO-EVICT', on: 'ON', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'NO-EVICT', off: 'OFF', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'NO-TOUCH', on: 'ON', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'NO-TOUCH', off: 'OFF', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'PAUSE', timeout: number | string, write: 'WRITE', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
client(subcommand: 'PAUSE', timeout: number | string, all: 'ALL', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
client(subcommand: 'PAUSE', timeout: number | string, callback?: Callback<"OK">): Result<"OK", Context>;
|
|
client(subcommand: 'REPLY', on: 'ON', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'REPLY', off: 'OFF', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'REPLY', skip: 'SKIP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'SETINFO', libnameToken: 'LIB-NAME', libname: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
clientBuffer(subcommand: 'SETINFO', libnameToken: 'LIB-NAME', libname: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
client(subcommand: 'SETINFO', libverToken: 'LIB-VER', libver: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
clientBuffer(subcommand: 'SETINFO', libverToken: 'LIB-VER', libver: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
client(subcommand: 'SETNAME', connectionName: string | Buffer, callback?: Callback<"OK">): Result<"OK", Context>;
|
|
client(...args: [
|
|
subcommand: 'TRACKING',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
client(...args: [
|
|
subcommand: 'TRACKING',
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
client(subcommand: 'TRACKINGINFO', callback?: Callback<string>): Result<string, Context>;
|
|
clientBuffer(subcommand: 'TRACKINGINFO', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
client(subcommand: 'UNBLOCK', clientId: number | string, timeout: 'TIMEOUT', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'UNBLOCK', clientId: number | string, error: 'ERROR', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'UNBLOCK', clientId: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
client(subcommand: 'UNPAUSE', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
cluster(...args: [
|
|
subcommand: 'ADDSLOTS',
|
|
...slots: (number | string)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'ADDSLOTS',
|
|
slots: (number | string)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'ADDSLOTS',
|
|
...slots: (number | string)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'ADDSLOTS',
|
|
slots: (number | string)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'ADDSLOTSRANGE',
|
|
...ranges: (string | number)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'ADDSLOTSRANGE',
|
|
...ranges: (string | number)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'BUMPEPOCH', callback?: Callback<'BUMPED' | 'STILL'>): Result<'BUMPED' | 'STILL', Context>;
|
|
cluster(subcommand: 'COUNT-FAILURE-REPORTS', nodeId: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
cluster(subcommand: 'COUNTKEYSINSLOT', slot: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
cluster(...args: [
|
|
subcommand: 'DELSLOTS',
|
|
...slots: (number | string)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'DELSLOTS',
|
|
slots: (number | string)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'DELSLOTS',
|
|
...slots: (number | string)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'DELSLOTS',
|
|
slots: (number | string)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'DELSLOTSRANGE',
|
|
...ranges: (string | number)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'DELSLOTSRANGE',
|
|
...ranges: (string | number)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'FAILOVER', force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'FAILOVER', takeover: 'TAKEOVER', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'FAILOVER', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'FLUSHSLOTS', callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'FORGET', nodeId: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'GETKEYSINSLOT', slot: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
cluster(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'INFO', callback?: Callback<string>): Result<string, Context>;
|
|
cluster(subcommand: 'KEYSLOT', key: string | Buffer, callback?: Callback<number>): Result<number, Context>;
|
|
cluster(subcommand: 'LINKS', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
cluster(subcommand: 'MEET', ip: string | Buffer, port: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'MEET', ip: string | Buffer, port: number | string, clusterBusPort: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'MIGRATION', cancel: 'CANCEL', taskIdToken: 'ID', taskId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'MIGRATION', cancel: 'CANCEL', all: 'ALL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'MIGRATION', status: 'STATUS', taskIdToken: 'ID', taskId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'MIGRATION', status: 'STATUS', all: 'ALL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(...args: [
|
|
subcommand: 'MIGRATION',
|
|
importToken: 'IMPORT',
|
|
...imports: (string | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
cluster(...args: [
|
|
subcommand: 'MIGRATION',
|
|
importToken: 'IMPORT',
|
|
...imports: (string | number)[]
|
|
]): Result<unknown, Context>;
|
|
cluster(subcommand: 'MIGRATION', status: 'STATUS', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'MIGRATION', status: 'STATUS', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'MYID', callback?: Callback<string>): Result<string, Context>;
|
|
cluster(subcommand: 'MYSHARDID', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'NODES', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'REPLICAS', nodeId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'REPLICATE', nodeId: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'RESET', hard: 'HARD', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'RESET', soft: 'SOFT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'RESET', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SAVECONFIG', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SET-CONFIG-EPOCH', configEpoch: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SETSLOT', slot: number | string, importingToken: 'IMPORTING', importing: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SETSLOT', slot: number | string, migratingToken: 'MIGRATING', migrating: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SETSLOT', slot: number | string, nodeToken: 'NODE', node: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SETSLOT', slot: number | string, stable: 'STABLE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
cluster(subcommand: 'SHARDS', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLAVES', nodeId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', orderbyToken: 'ORDERBY', metric: string | Buffer, limitToken: 'LIMIT', limit: number | string, asc: 'ASC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', orderbyToken: 'ORDERBY', metric: string | Buffer, limitToken: 'LIMIT', limit: number | string, desc: 'DESC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', orderbyToken: 'ORDERBY', metric: string | Buffer, asc: 'ASC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', orderbyToken: 'ORDERBY', metric: string | Buffer, desc: 'DESC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', orderbyToken: 'ORDERBY', metric: string | Buffer, limitToken: 'LIMIT', limit: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', slotsrangeToken: 'SLOTSRANGE', startSlot: number | string, endSlot: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOT-STATS', orderbyToken: 'ORDERBY', metric: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
cluster(subcommand: 'SLOTS', callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'SYNCSLOTS',
|
|
syncToken: 'SYNC',
|
|
taskId: string | Buffer | number,
|
|
...slotRanges: (string | number)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'SYNCSLOTS',
|
|
syncToken: 'SYNC',
|
|
taskId: string | Buffer | number,
|
|
...slotRanges: (string | number)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'SYNCSLOTS', taskIdToken: 'RDBCHANNEL', taskId: string | Buffer | number, callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'SYNCSLOTS', snapshotEof: 'SNAPSHOT-EOF', callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'SYNCSLOTS', streamEof: 'STREAM-EOF', callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'SYNCSLOTS', ackToken: 'ACK', state: string | Buffer, offset: number | string, callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(subcommand: 'SYNCSLOTS', errorToken: 'FAIL', error: string | Buffer, callback?: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'SYNCSLOTS',
|
|
confToken: 'CONF',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][]>
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
cluster(...args: [
|
|
subcommand: 'SYNCSLOTS',
|
|
confToken: 'CONF',
|
|
...args: (RedisValue)[]
|
|
]): Result<[
|
|
startSlotRange: number,
|
|
endSlotRange: number,
|
|
...nodes: [
|
|
host: string,
|
|
port: number,
|
|
nodeId: string,
|
|
info: unknown[]
|
|
][]
|
|
][], Context>;
|
|
command(subcommand: 'COUNT', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(subcommand: 'DOCS', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'DOCS',
|
|
...commandNames: (string | Buffer)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'DOCS',
|
|
...commandNames: (string | Buffer)[]
|
|
]): Result<unknown[], Context>;
|
|
command(subcommand: 'GETKEYS', command: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'GETKEYS',
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'GETKEYS',
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown[], Context>;
|
|
command(subcommand: 'GETKEYSANDFLAGS', command: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'GETKEYSANDFLAGS',
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'GETKEYSANDFLAGS',
|
|
command: string | Buffer,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown[], Context>;
|
|
command(subcommand: 'HELP', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(subcommand: 'INFO', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'INFO',
|
|
...commandNames: (string | Buffer)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
command(...args: [
|
|
subcommand: 'INFO',
|
|
...commandNames: (string | Buffer)[]
|
|
]): Result<unknown[], Context>;
|
|
command(subcommand: 'LIST', filterby: 'FILTERBY', moduleNameToken: 'MODULE', moduleName: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(subcommand: 'LIST', filterby: 'FILTERBY', categoryToken: 'ACLCAT', category: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(subcommand: 'LIST', filterby: 'FILTERBY', patternToken: 'PATTERN', pattern: string, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
command(subcommand: 'LIST', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
config(...args: [
|
|
subcommand: 'GET',
|
|
...parameters: (string | Buffer)[],
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, Context>, Context>;
|
|
configBuffer(...args: [
|
|
subcommand: 'GET',
|
|
...parameters: (string | Buffer)[],
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, Context>, Context>;
|
|
config(...args: [
|
|
subcommand: 'GET',
|
|
...parameters: (string | Buffer)[]
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, Context>, Context>;
|
|
configBuffer(...args: [
|
|
subcommand: 'GET',
|
|
...parameters: (string | Buffer)[]
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, Context>, Context>;
|
|
config(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
config(subcommand: 'RESETSTAT', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
config(subcommand: 'REWRITE', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
config(...args: [
|
|
subcommand: 'SET',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
config(...args: [
|
|
subcommand: 'SET',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
copy(source: RedisKey, destination: RedisKey, destinationDbToken: 'DB', destinationDb: number | string, replace: 'REPLACE', callback?: Callback<number>): Result<number, Context>;
|
|
copy(source: RedisKey, destination: RedisKey, replace: 'REPLACE', callback?: Callback<number>): Result<number, Context>;
|
|
copy(source: RedisKey, destination: RedisKey, destinationDbToken: 'DB', destinationDb: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
copy(source: RedisKey, destination: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
dbsize(callback?: Callback<number>): Result<number, Context>;
|
|
debug(subcommand: string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
debug(...args: [
|
|
subcommand: string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
debug(...args: [
|
|
subcommand: string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
decr(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
decrby(key: RedisKey, decrement: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
del(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
del(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
del(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
del(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
discard(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
dump(key: RedisKey, callback?: Callback<string>): Result<string, Context>;
|
|
dumpBuffer(key: RedisKey, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
echo(message: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
echoBuffer(message: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
eval(script: string | Buffer, numkeys: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
eval_ro(script: string | Buffer, numkeys: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
eval_ro(...args: [
|
|
script: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha(sha1: string | Buffer, numkeys: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(sha1: string | Buffer, numkeys: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
evalsha_ro(...args: [
|
|
sha1: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
exec(callback?: Callback<[
|
|
error: Error | null,
|
|
result: unknown
|
|
][] | null>): Promise<[
|
|
error: Error | null,
|
|
result: unknown
|
|
][] | null>;
|
|
exists(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
exists(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
exists(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
exists(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
expire(key: RedisKey, seconds: number | string, nx: 'NX', callback?: Callback<number>): Result<number, Context>;
|
|
expire(key: RedisKey, seconds: number | string, xx: 'XX', callback?: Callback<number>): Result<number, Context>;
|
|
expire(key: RedisKey, seconds: number | string, gt: 'GT', callback?: Callback<number>): Result<number, Context>;
|
|
expire(key: RedisKey, seconds: number | string, lt: 'LT', callback?: Callback<number>): Result<number, Context>;
|
|
expire(key: RedisKey, seconds: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
expireat(key: RedisKey, unixTimeSeconds: number | string, nx: 'NX', callback?: Callback<number>): Result<number, Context>;
|
|
expireat(key: RedisKey, unixTimeSeconds: number | string, xx: 'XX', callback?: Callback<number>): Result<number, Context>;
|
|
expireat(key: RedisKey, unixTimeSeconds: number | string, gt: 'GT', callback?: Callback<number>): Result<number, Context>;
|
|
expireat(key: RedisKey, unixTimeSeconds: number | string, lt: 'LT', callback?: Callback<number>): Result<number, Context>;
|
|
expireat(key: RedisKey, unixTimeSeconds: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
expiretime(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, force: 'FORCE', abort: 'ABORT', millisecondsToken: 'TIMEOUT', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, abort: 'ABORT', millisecondsToken: 'TIMEOUT', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, force: 'FORCE', millisecondsToken: 'TIMEOUT', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(abort: 'ABORT', millisecondsToken: 'TIMEOUT', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, millisecondsToken: 'TIMEOUT', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(millisecondsToken: 'TIMEOUT', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(targetToken: 'TO', host: string | Buffer, port: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
failover(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
fcall(func: string | Buffer, numkeys: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(func: string | Buffer, numkeys: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
fcall_ro(...args: [
|
|
func: string | Buffer,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
flushall(async: 'ASYNC', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
flushall(sync: 'SYNC', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
flushall(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
flushdb(async: 'ASYNC', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
flushdb(sync: 'SYNC', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
flushdb(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
function(subcommand: 'DELETE', libraryName: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'DELETE', libraryName: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'DUMP', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'DUMP', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'FLUSH', async: 'ASYNC', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'FLUSH', async: 'ASYNC', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'FLUSH', sync: 'SYNC', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'FLUSH', sync: 'SYNC', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'FLUSH', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'FLUSH', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
function(subcommand: 'KILL', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'KILL', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'LIST', libraryNamePatternToken: 'LIBRARYNAME', libraryNamePattern: string | Buffer, withcode: 'WITHCODE', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
function(subcommand: 'LIST', withcode: 'WITHCODE', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
function(subcommand: 'LIST', libraryNamePatternToken: 'LIBRARYNAME', libraryNamePattern: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
function(subcommand: 'LIST', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
function(subcommand: 'LOAD', replace: 'REPLACE', functionCode: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'LOAD', replace: 'REPLACE', functionCode: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'LOAD', functionCode: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'LOAD', functionCode: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'RESTORE', serializedValue: string | Buffer | number, flush: 'FLUSH', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'RESTORE', serializedValue: string | Buffer | number, flush: 'FLUSH', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'RESTORE', serializedValue: string | Buffer | number, append: 'APPEND', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'RESTORE', serializedValue: string | Buffer | number, append: 'APPEND', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'RESTORE', serializedValue: string | Buffer | number, replace: 'REPLACE', callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'RESTORE', serializedValue: string | Buffer | number, replace: 'REPLACE', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'RESTORE', serializedValue: string | Buffer | number, callback?: Callback<string>): Result<string, Context>;
|
|
functionBuffer(subcommand: 'RESTORE', serializedValue: string | Buffer | number, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
function(subcommand: 'STATS', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geoadd(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
geodist(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, m: 'M', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
geodistBuffer(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, m: 'M', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
geodist(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, km: 'KM', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
geodistBuffer(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, km: 'KM', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
geodist(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, ft: 'FT', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
geodistBuffer(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, ft: 'FT', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
geodist(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, mi: 'MI', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
geodistBuffer(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, mi: 'MI', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
geodist(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
geodistBuffer(key: RedisKey, member1: string | Buffer | number, member2: string | Buffer | number, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
geohash(key: RedisKey, callback?: Callback<string[]>): Result<string[], Context>;
|
|
geohashBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
geohash(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
geohashBuffer(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
geohash(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
geohashBuffer(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
geohash(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<string[], Context>;
|
|
geohashBuffer(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<Buffer[], Context>;
|
|
geohash(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<string[], Context>;
|
|
geohashBuffer(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<Buffer[], Context>;
|
|
geopos(key: RedisKey, callback?: Callback<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>>): Result<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>, Context>;
|
|
geopos(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>>
|
|
]): Result<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>, Context>;
|
|
geopos(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>>
|
|
]): Result<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>, Context>;
|
|
geopos(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>, Context>;
|
|
geopos(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<([
|
|
longitude: string,
|
|
latitude: string
|
|
] | null)[]>, Resp3<([
|
|
longitude: Resp3Double<string>,
|
|
latitude: Resp3Double<string>
|
|
] | null)[]>, Context>, Context>;
|
|
georadius(...args: [
|
|
key: RedisKey,
|
|
longitude: number | string,
|
|
latitude: number | string,
|
|
radius: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
georadius(...args: [
|
|
key: RedisKey,
|
|
longitude: number | string,
|
|
latitude: number | string,
|
|
radius: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown[], Context>;
|
|
georadius_ro(...args: [
|
|
key: RedisKey,
|
|
longitude: number | string,
|
|
latitude: number | string,
|
|
radius: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
georadius_ro(...args: [
|
|
key: RedisKey,
|
|
longitude: number | string,
|
|
latitude: number | string,
|
|
radius: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
georadiusbymember(...args: [
|
|
key: RedisKey,
|
|
member: string | Buffer | number,
|
|
radius: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
georadiusbymember(...args: [
|
|
key: RedisKey,
|
|
member: string | Buffer | number,
|
|
radius: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
georadiusbymember_ro(...args: [
|
|
key: RedisKey,
|
|
member: string | Buffer | number,
|
|
radius: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
georadiusbymember_ro(...args: [
|
|
key: RedisKey,
|
|
member: string | Buffer | number,
|
|
radius: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
geosearch(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
geosearch(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown[], Context>;
|
|
geosearchstore(...args: [
|
|
destination: RedisKey,
|
|
source: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
geosearchstore(...args: [
|
|
destination: RedisKey,
|
|
source: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<number, Context>;
|
|
get(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getbit(key: RedisKey, offset: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
getdel(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getdelBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getex(key: RedisKey, secondsToken: 'EX', seconds: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getexBuffer(key: RedisKey, secondsToken: 'EX', seconds: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getex(key: RedisKey, millisecondsToken: 'PX', milliseconds: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getexBuffer(key: RedisKey, millisecondsToken: 'PX', milliseconds: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getex(key: RedisKey, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getexBuffer(key: RedisKey, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getex(key: RedisKey, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getexBuffer(key: RedisKey, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getex(key: RedisKey, persist: 'PERSIST', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getexBuffer(key: RedisKey, persist: 'PERSIST', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getex(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getexBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
getrange(key: RedisKey, start: number | string, end: number | string, callback?: Callback<string>): Result<string, Context>;
|
|
getrangeBuffer(key: RedisKey, start: number | string, end: number | string, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
getset(key: RedisKey, value: string | Buffer | number, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
getsetBuffer(key: RedisKey, value: string | Buffer | number, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
hdel(...args: [
|
|
key: RedisKey,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hdel(...args: [
|
|
key: RedisKey,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number, Context>;
|
|
hello(protover: number | string, authToken: 'AUTH', username: string | Buffer, password: string | Buffer, clientnameToken: 'SETNAME', clientname: string | Buffer, callback?: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>>): Result<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>, Context>;
|
|
hello(protover: number | string, clientnameToken: 'SETNAME', clientname: string | Buffer, callback?: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>>): Result<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>, Context>;
|
|
hello(protover: number | string, authToken: 'AUTH', username: string | Buffer, password: string | Buffer, callback?: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>>): Result<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>, Context>;
|
|
hello(callback?: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>>): Result<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>, Context>;
|
|
hello(protover: number | string, callback?: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>>): Result<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>, Context>;
|
|
hexists(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Result<number, Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpire(...args: [
|
|
key: RedisKey,
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hexpiretime(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hexpiretime(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hget(key: RedisKey, field: string | Buffer, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
hgetBuffer(key: RedisKey, field: string | Buffer, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
hgetall(key: RedisKey, callback?: Callback<Record<string, string>>): Result<Record<string, string>, Context>;
|
|
hgetallBuffer(key: RedisKey, callback?: Callback<Record<string, Buffer>>): Result<Record<string, Buffer>, Context>;
|
|
hgetdel(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetdelBuffer(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetdel(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetdelBuffer(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
persist: 'PERSIST',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
persist: 'PERSIST',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
persist: 'PERSIST',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
persist: 'PERSIST',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hgetex(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hgetexBuffer(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
himport(subcommand: 'DISCARD', fieldsetName: string | Buffer, callback?: Callback<number>): Result<number, Context>;
|
|
himport(subcommand: 'DISCARDALL', callback?: Callback<number>): Result<number, Context>;
|
|
himport(...args: [
|
|
subcommand: 'PREPARE',
|
|
fieldsetName: string | Buffer,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
himport(...args: [
|
|
subcommand: 'PREPARE',
|
|
fieldsetName: string | Buffer,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<'OK', Context>;
|
|
himport(...args: [
|
|
subcommand: 'SET',
|
|
key: RedisKey,
|
|
fieldsetName: string | Buffer,
|
|
...values: (string | Buffer | number)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
himport(...args: [
|
|
subcommand: 'SET',
|
|
key: RedisKey,
|
|
fieldsetName: string | Buffer,
|
|
...values: (string | Buffer | number)[]
|
|
]): Result<'OK', Context>;
|
|
hincrby(key: RedisKey, field: string | Buffer, increment: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
hincrbyfloat(key: RedisKey, field: string | Buffer, increment: number | string, callback?: Callback<string>): Result<string, Context>;
|
|
hincrbyfloatBuffer(key: RedisKey, field: string | Buffer, increment: number | string, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
hkeys(key: RedisKey, callback?: Callback<string[]>): Result<string[], Context>;
|
|
hkeysBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
hlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
hmget(...args: [
|
|
key: RedisKey,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
hmgetBuffer(...args: [
|
|
key: RedisKey,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hmget(...args: [
|
|
key: RedisKey,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(string | null)[], Context>;
|
|
hmgetBuffer(...args: [
|
|
key: RedisKey,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
hmset(key: RedisKey, object: object, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
hmset(key: RedisKey, map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
hmset(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
hmset(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<'OK', Context>;
|
|
hpersist(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpersist(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpire(...args: [
|
|
key: RedisKey,
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
nx: 'NX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
xx: 'XX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
gt: 'GT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
lt: 'LT',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpireat(...args: [
|
|
key: RedisKey,
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpexpiretime(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpexpiretime(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hpttl(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
hpttl(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hrandfield(key: RedisKey, count: number | string, withvalues: 'WITHVALUES', callback?: Callback<string | unknown[] | null>): Result<string | unknown[] | null, Context>;
|
|
hrandfieldBuffer(key: RedisKey, count: number | string, withvalues: 'WITHVALUES', callback?: Callback<Buffer | unknown[] | null>): Result<Buffer | unknown[] | null, Context>;
|
|
hrandfield(key: RedisKey, callback?: Callback<string | unknown[] | null>): Result<string | unknown[] | null, Context>;
|
|
hrandfieldBuffer(key: RedisKey, callback?: Callback<Buffer | unknown[] | null>): Result<Buffer | unknown[] | null, Context>;
|
|
hrandfield(key: RedisKey, count: number | string, callback?: Callback<string | unknown[] | null>): Result<string | unknown[] | null, Context>;
|
|
hrandfieldBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer | unknown[] | null>): Result<Buffer | unknown[] | null, Context>;
|
|
hscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, novalues: 'NOVALUES', callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hscan(key: RedisKey, cursor: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
hscanBuffer(key: RedisKey, cursor: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
hset(key: RedisKey, object: object, callback?: Callback<number>): Result<number, Context>;
|
|
hset(key: RedisKey, map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<number>): Result<number, Context>;
|
|
hset(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hset(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
keepttl: 'KEEPTTL',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
keepttl: 'KEEPTTL',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
keepttl: 'KEEPTTL',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
keepttl: 'KEEPTTL',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
keepttl: 'KEEPTTL',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
keepttl: 'KEEPTTL',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fnx: 'FNX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fxx: 'FXX',
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
hsetex(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
hsetnx(key: RedisKey, field: string | Buffer, value: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
hstrlen(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Result<number, Context>;
|
|
httl(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
httl(...args: [
|
|
key: RedisKey,
|
|
fieldsToken: 'FIELDS',
|
|
numfields: number | string,
|
|
...fields: (string | Buffer)[]
|
|
]): Result<number[], Context>;
|
|
hvals(key: RedisKey, callback?: Callback<string[]>): Result<string[], Context>;
|
|
hvalsBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
incr(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
incrby(key: RedisKey, increment: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
incrbyfloat(key: RedisKey, increment: number | string, callback?: Callback<string>): Result<string, Context>;
|
|
increx(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
value: number,
|
|
increment: number
|
|
] | [
|
|
value: string,
|
|
increment: string
|
|
]>, Resp3<[
|
|
value: number,
|
|
increment: number
|
|
]>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
value: number,
|
|
increment: number
|
|
] | [
|
|
value: string,
|
|
increment: string
|
|
]>, Resp3<[
|
|
value: number,
|
|
increment: number
|
|
]>, Context>, Context>;
|
|
increxBuffer(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
value: number,
|
|
increment: number
|
|
] | [
|
|
value: Buffer,
|
|
increment: Buffer
|
|
]>, Resp3<[
|
|
value: number,
|
|
increment: number
|
|
]>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
value: number,
|
|
increment: number
|
|
] | [
|
|
value: Buffer,
|
|
increment: Buffer
|
|
]>, Resp3<[
|
|
value: number,
|
|
increment: number
|
|
]>, Context>, Context>;
|
|
increx(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
value: number,
|
|
increment: number
|
|
] | [
|
|
value: string,
|
|
increment: string
|
|
]>, Resp3<[
|
|
value: number,
|
|
increment: number
|
|
]>, Context>, Context>;
|
|
increxBuffer(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
value: number,
|
|
increment: number
|
|
] | [
|
|
value: Buffer,
|
|
increment: Buffer
|
|
]>, Resp3<[
|
|
value: number,
|
|
increment: number
|
|
]>, Context>, Context>;
|
|
info(callback?: Callback<string>): Result<string, Context>;
|
|
info(...args: [
|
|
...sections: (string | Buffer)[],
|
|
callback: Callback<string>
|
|
]): Result<string, Context>;
|
|
info(...args: [
|
|
...sections: (string | Buffer)[]
|
|
]): Result<string, Context>;
|
|
keys(pattern: string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
keysBuffer(pattern: string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
lastsave(callback?: Callback<number>): Result<number, Context>;
|
|
latency(subcommand: 'DOCTOR', callback?: Callback<string>): Result<string, Context>;
|
|
latency(subcommand: 'GRAPH', event: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
latency(subcommand: 'HELP', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
latency(subcommand: 'HISTOGRAM', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
latency(...args: [
|
|
subcommand: 'HISTOGRAM',
|
|
...commands: (string | Buffer)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
latency(...args: [
|
|
subcommand: 'HISTOGRAM',
|
|
...commands: (string | Buffer)[]
|
|
]): Result<unknown, Context>;
|
|
latency(subcommand: 'HISTORY', event: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
latency(subcommand: 'LATEST', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
latency(subcommand: 'RESET', callback?: Callback<number>): Result<number, Context>;
|
|
latency(...args: [
|
|
subcommand: 'RESET',
|
|
...events: (string | Buffer)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
latency(...args: [
|
|
subcommand: 'RESET',
|
|
...events: (string | Buffer)[]
|
|
]): Result<number, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', idx: 'IDX', minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, idx: 'IDX', minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', idx: 'IDX', withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', idx: 'IDX', minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, idx: 'IDX', withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, idx: 'IDX', minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', idx: 'IDX', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, withmatchlen: 'WITHMATCHLEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, minMatchLenToken: 'MINMATCHLEN', minMatchLen: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, idx: 'IDX', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, len: 'LEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lcs(key1: RedisKey, key2: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
lindex(key: RedisKey, index: number | string, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
lindexBuffer(key: RedisKey, index: number | string, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
linsert(key: RedisKey, before: 'BEFORE', pivot: string | Buffer | number, element: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
linsert(key: RedisKey, after: 'AFTER', pivot: string | Buffer | number, element: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
llen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
lmove(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', callback?: Callback<string>): Result<string, Context>;
|
|
lmoveBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
lmove(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', callback?: Callback<string>): Result<string, Context>;
|
|
lmoveBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
lmove(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', callback?: Callback<string>): Result<string, Context>;
|
|
lmoveBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
lmove(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', callback?: Callback<string>): Result<string, Context>;
|
|
lmoveBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', countToken: 'COUNT', count: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', countToken: 'COUNT', count: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, obo: 'OBO', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', exactlyToken: 'EXACTLY', exactly: number | string, bulk: 'BULK', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', left1: 'LEFT', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, left: 'LEFT', right: 'RIGHT', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', left: 'LEFT', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmovem(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lmovemBuffer(source: RedisKey, destination: RedisKey, right: 'RIGHT', right1: 'RIGHT', callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
left: 'LEFT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: string,
|
|
members: string[]
|
|
] | null>
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT',
|
|
callback: Callback<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null>
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: string,
|
|
members: string[]
|
|
] | null, Context>;
|
|
lmpopBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
right: 'RIGHT'
|
|
]): Result<[
|
|
key: Buffer,
|
|
members: Buffer[]
|
|
] | null, Context>;
|
|
lolwut(versionToken: 'VERSION', version: number | string, callback?: Callback<string>): Result<string, Context>;
|
|
lolwut(callback?: Callback<string>): Result<string, Context>;
|
|
lpop(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
lpopBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
lpop(key: RedisKey, count: number | string, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
lpopBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, rankToken: 'RANK', rank: number | string, numMatchesToken: 'COUNT', numMatches: number | string, lenToken: 'MAXLEN', len: number | string, callback?: Callback<number[]>): Result<number[], Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, numMatchesToken: 'COUNT', numMatches: number | string, lenToken: 'MAXLEN', len: number | string, callback?: Callback<number[]>): Result<number[], Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, rankToken: 'RANK', rank: number | string, lenToken: 'MAXLEN', len: number | string, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, rankToken: 'RANK', rank: number | string, numMatchesToken: 'COUNT', numMatches: number | string, callback?: Callback<number[]>): Result<number[], Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, lenToken: 'MAXLEN', len: number | string, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, numMatchesToken: 'COUNT', numMatches: number | string, callback?: Callback<number[]>): Result<number[], Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, rankToken: 'RANK', rank: number | string, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
lpos(key: RedisKey, element: string | Buffer | number, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
lpush(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
lpush(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
lpushx(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
lpushx(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
lrange(key: RedisKey, start: number | string, stop: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
lrangeBuffer(key: RedisKey, start: number | string, stop: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
lrem(key: RedisKey, count: number | string, element: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
lset(key: RedisKey, index: number | string, element: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
ltrim(key: RedisKey, start: number | string, stop: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
memory(subcommand: 'DOCTOR', callback?: Callback<string>): Result<string, Context>;
|
|
memory(subcommand: 'HELP', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
memory(subcommand: 'MALLOC-STATS', callback?: Callback<string>): Result<string, Context>;
|
|
memory(subcommand: 'PURGE', callback?: Callback<"OK">): Result<"OK", Context>;
|
|
memory(subcommand: 'STATS', callback?: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>>): Result<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, Context>, Context>;
|
|
memory(subcommand: 'USAGE', key: RedisKey, countToken: 'SAMPLES', count: number | string, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
memory(subcommand: 'USAGE', key: RedisKey, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
mget(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
mgetBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
mget(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<(string | null)[]>
|
|
]): Result<(string | null)[], Context>;
|
|
mgetBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<(Buffer | null)[]>
|
|
]): Result<(Buffer | null)[], Context>;
|
|
mget(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<(string | null)[], Context>;
|
|
mgetBuffer(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
mget(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<(string | null)[], Context>;
|
|
mgetBuffer(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<(Buffer | null)[], Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, copy: 'COPY', replace: 'REPLACE', authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, copy: 'COPY', replace: 'REPLACE', auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, copy: 'COPY', replace: 'REPLACE', authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, copy: 'COPY', replace: 'REPLACE', auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, replace: 'REPLACE', authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, replace: 'REPLACE', auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, copy: 'COPY', authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, copy: 'COPY', auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, copy: 'COPY', replace: 'REPLACE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
authToken: 'AUTH',
|
|
auth: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
auth2Token: 'AUTH2',
|
|
username: string | Buffer,
|
|
password: string | Buffer,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
replace: 'REPLACE',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, replace: 'REPLACE', authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, replace: 'REPLACE', auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
copy: 'COPY',
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, copy: 'COPY', authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, copy: 'COPY', auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, copy: 'COPY', replace: 'REPLACE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
key: RedisKey,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, replace: 'REPLACE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, copy: 'COPY', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(...args: [
|
|
host: string | Buffer,
|
|
port: number | string,
|
|
destinationDb: number | string,
|
|
timeout: number | string,
|
|
keysToken: 'KEYS',
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, authToken: 'AUTH', auth: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, auth2Token: 'AUTH2', username: string | Buffer, password: string | Buffer, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, replace: 'REPLACE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, copy: 'COPY', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, key: RedisKey, destinationDb: number | string, timeout: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
migrate(host: string | Buffer, port: number | string, destinationDb: number | string, timeout: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
module(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
module(subcommand: 'LIST', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
module(subcommand: 'LOAD', path: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOAD',
|
|
path: string | Buffer,
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOAD',
|
|
path: string | Buffer,
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOADEX',
|
|
path: string | Buffer,
|
|
argsToken: 'ARGS',
|
|
...args: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOADEX',
|
|
path: string | Buffer,
|
|
argsToken: 'ARGS',
|
|
...args: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOADEX',
|
|
path: string | Buffer,
|
|
configsToken: 'CONFIG',
|
|
...configs: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOADEX',
|
|
path: string | Buffer,
|
|
configsToken: 'CONFIG',
|
|
...configs: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOADEX',
|
|
path: string | Buffer,
|
|
configsToken: 'CONFIG',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
module(...args: [
|
|
subcommand: 'LOADEX',
|
|
path: string | Buffer,
|
|
configsToken: 'CONFIG',
|
|
...args: (RedisValue)[]
|
|
]): Result<unknown, Context>;
|
|
module(subcommand: 'LOADEX', path: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
module(subcommand: 'UNLOAD', name: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
move(key: RedisKey, db: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
mset(object: object, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
mset(map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
mset(...args: [
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
mset(...args: [
|
|
...data: (RedisKey | string | Buffer | number)[]
|
|
]): Result<'OK', Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
keepttl: 'KEEPTTL',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
keepttl: 'KEEPTTL'
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
secondsToken: 'EX',
|
|
seconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
keepttl: 'KEEPTTL',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
keepttl: 'KEEPTTL'
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
secondsToken: 'EX',
|
|
seconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
secondsToken: 'EX',
|
|
seconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
millisecondsToken: 'PX',
|
|
milliseconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
unixTimeSecondsToken: 'EXAT',
|
|
unixTimeSeconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'PXAT',
|
|
unixTimeMilliseconds: number | string
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
keepttl: 'KEEPTTL',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
keepttl: 'KEEPTTL'
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
nx: 'NX'
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
xx: 'XX'
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetex(...args: [
|
|
numkeys: number | string,
|
|
...data: (RedisKey | string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
msetnx(object: object, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
msetnx(map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
msetnx(...args: [
|
|
...data: (RedisKey | string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
msetnx(...args: [
|
|
...data: (RedisKey | string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
object(subcommand: 'ENCODING', key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
object(subcommand: 'FREQ', key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
object(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
object(subcommand: 'IDLETIME', key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
object(subcommand: 'REFCOUNT', key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
persist(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
pexpire(key: RedisKey, milliseconds: number | string, nx: 'NX', callback?: Callback<number>): Result<number, Context>;
|
|
pexpire(key: RedisKey, milliseconds: number | string, xx: 'XX', callback?: Callback<number>): Result<number, Context>;
|
|
pexpire(key: RedisKey, milliseconds: number | string, gt: 'GT', callback?: Callback<number>): Result<number, Context>;
|
|
pexpire(key: RedisKey, milliseconds: number | string, lt: 'LT', callback?: Callback<number>): Result<number, Context>;
|
|
pexpire(key: RedisKey, milliseconds: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
pexpireat(key: RedisKey, unixTimeMilliseconds: number | string, nx: 'NX', callback?: Callback<number>): Result<number, Context>;
|
|
pexpireat(key: RedisKey, unixTimeMilliseconds: number | string, xx: 'XX', callback?: Callback<number>): Result<number, Context>;
|
|
pexpireat(key: RedisKey, unixTimeMilliseconds: number | string, gt: 'GT', callback?: Callback<number>): Result<number, Context>;
|
|
pexpireat(key: RedisKey, unixTimeMilliseconds: number | string, lt: 'LT', callback?: Callback<number>): Result<number, Context>;
|
|
pexpireat(key: RedisKey, unixTimeMilliseconds: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
pexpiretime(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
pfadd(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
pfadd(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
pfadd(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
pfcount(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
pfcount(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
pfcount(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
pfcount(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
pfdebug(subcommand: string | Buffer, key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
pfmerge(destkey: RedisKey, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
pfmerge(...args: [
|
|
destkey: RedisKey,
|
|
...sourcekeys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
pfmerge(...args: [
|
|
destkey: RedisKey,
|
|
sourcekeys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
pfmerge(...args: [
|
|
destkey: RedisKey,
|
|
...sourcekeys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
pfmerge(...args: [
|
|
destkey: RedisKey,
|
|
sourcekeys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
pfselftest(callback?: Callback<unknown>): Result<unknown, Context>;
|
|
ping(callback?: Callback<'PONG'>): Result<'PONG', Context>;
|
|
ping(message: string | Buffer, callback?: Callback<string>): Result<string, Context>;
|
|
pingBuffer(message: string | Buffer, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
psetex(key: RedisKey, milliseconds: number | string, value: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
psubscribe(...args: [
|
|
...patterns: (string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
psubscribe(...args: [
|
|
...patterns: (string)[]
|
|
]): Result<unknown, Context>;
|
|
psync(replicationid: string | Buffer | number, offset: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
pttl(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
publish(channel: string | Buffer, message: string | Buffer, callback?: Callback<number>): Result<number, Context>;
|
|
pubsub(subcommand: 'CHANNELS', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'CHANNELS', pattern: string, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'HELP', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'NUMPAT', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'NUMSUB', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(...args: [
|
|
subcommand: 'NUMSUB',
|
|
...channels: (string | Buffer)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
pubsub(...args: [
|
|
subcommand: 'NUMSUB',
|
|
...channels: (string | Buffer)[]
|
|
]): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'SHARDCHANNELS', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'SHARDCHANNELS', pattern: string, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(subcommand: 'SHARDNUMSUB', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
pubsub(...args: [
|
|
subcommand: 'SHARDNUMSUB',
|
|
...shardchannels: (string | Buffer)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
pubsub(...args: [
|
|
subcommand: 'SHARDNUMSUB',
|
|
...shardchannels: (string | Buffer)[]
|
|
]): Result<unknown[], Context>;
|
|
punsubscribe(callback?: Callback<unknown>): Result<unknown, Context>;
|
|
punsubscribe(...args: [
|
|
...patterns: (string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
punsubscribe(...args: [
|
|
...patterns: (string)[]
|
|
]): Result<unknown, Context>;
|
|
quit(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
randomkey(callback?: Callback<string | null>): Result<string | null, Context>;
|
|
randomkeyBuffer(callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
readonly(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
readwrite(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
rename(key: RedisKey, newkey: RedisKey, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
renamenx(key: RedisKey, newkey: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
replconf(callback?: Callback<unknown>): Result<unknown, Context>;
|
|
replicaof(no: 'NO', one: 'ONE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
replicaof(host: string | Buffer, port: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
reset(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
restore(key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, secondsToken: 'IDLETIME', seconds: number | string, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', absttl: 'ABSTTL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, frequencyToken: 'FREQ', frequency: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, secondsToken: 'IDLETIME', seconds: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, absttl: 'ABSTTL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, replace: 'REPLACE', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
['restore-asking'](key: RedisKey, ttl: number | string, serializedValue: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
role(callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
rpop(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
rpopBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
rpop(key: RedisKey, count: number | string, callback?: Callback<string[] | null>): Result<string[] | null, Context>;
|
|
rpopBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer[] | null>): Result<Buffer[] | null, Context>;
|
|
rpoplpush(source: RedisKey, destination: RedisKey, callback?: Callback<string>): Result<string, Context>;
|
|
rpoplpushBuffer(source: RedisKey, destination: RedisKey, callback?: Callback<Buffer>): Result<Buffer, Context>;
|
|
rpush(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
rpush(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
rpushx(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
rpushx(...args: [
|
|
key: RedisKey,
|
|
...elements: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
sadd(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sadd(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sadd(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
sadd(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
save(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
scan(cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, countToken: 'COUNT', count: number | string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, countToken: 'COUNT', count: number | string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, patternToken: 'MATCH', pattern: string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, patternToken: 'MATCH', pattern: string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, typeToken: 'TYPE', type: string | Buffer, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scan(cursor: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
scanBuffer(cursor: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
scard(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
script(subcommand: 'DEBUG', yes: 'YES', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'DEBUG', sync: 'SYNC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'DEBUG', no: 'NO', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(...args: [
|
|
subcommand: 'EXISTS',
|
|
...sha1s: (string | Buffer)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
script(...args: [
|
|
subcommand: 'EXISTS',
|
|
...sha1s: (string | Buffer)[]
|
|
]): Result<unknown, Context>;
|
|
script(subcommand: 'FLUSH', async: 'ASYNC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'FLUSH', sync: 'SYNC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'FLUSH', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
script(subcommand: 'LOAD', script: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sdiff(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
sdiffBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
sdiff(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
sdiffBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
sdiff(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
sdiffBuffer(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
sdiff(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
sdiffBuffer(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sdiffcard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sdiffstore(...args: [
|
|
destination: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sdiffstore(...args: [
|
|
destination: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sdiffstore(...args: [
|
|
destination: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sdiffstore(...args: [
|
|
destination: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
select(index: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, nx: 'NX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, xx: 'XX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', nx: 'NX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', nx: 'NX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', xx: 'XX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', xx: 'XX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, nx: 'NX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, nx: 'NX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, xx: 'XX', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, xx: 'XX', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, nx: 'NX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, xx: 'XX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, nx: 'NX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, xx: 'XX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, nx: 'NX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, xx: 'XX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, nx: 'NX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, xx: 'XX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', nx: 'NX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', xx: 'XX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, get: 'GET', callback?: Callback<string | null>): Result<string | null, Context>;
|
|
setBuffer(key: RedisKey, value: string | Buffer | number, get: 'GET', callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, nx: 'NX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, xx: 'XX', callback?: Callback<'OK' | null>): Result<'OK' | null, Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifeqValueToken: 'IFEQ', ifeqValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifneValueToken: 'IFNE', ifneValue: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifdeqDigestToken: 'IFDEQ', ifdeqDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, ifdneDigestToken: 'IFDNE', ifdneDigest: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, secondsToken: 'EX', seconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, millisecondsToken: 'PX', milliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeSecondsToken: 'EXAT', unixTimeSeconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, unixTimeMillisecondsToken: 'PXAT', unixTimeMilliseconds: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, keepttl: 'KEEPTTL', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
set(key: RedisKey, value: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
setbit(key: RedisKey, offset: number | string, value: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
setex(key: RedisKey, seconds: number | string, value: string | Buffer | number, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
setnx(key: RedisKey, value: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
setrange(key: RedisKey, offset: number | string, value: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
shutdown(nosave: 'NOSAVE', now: 'NOW', force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', now: 'NOW', force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(now: 'NOW', force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', now: 'NOW', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', now: 'NOW', force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', now: 'NOW', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', now: 'NOW', force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(now: 'NOW', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(now: 'NOW', force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', now: 'NOW', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', now: 'NOW', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(now: 'NOW', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(nosave: 'NOSAVE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(save: 'SAVE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
shutdown(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
sinter(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
sinterBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
sinter(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
sinterBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
sinter(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
sinterBuffer(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
sinter(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
sinterBuffer(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sinterstore(...args: [
|
|
destination: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sinterstore(...args: [
|
|
destination: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sinterstore(...args: [
|
|
destination: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sinterstore(...args: [
|
|
destination: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sismember(key: RedisKey, member: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
slaveof(no: 'NO', one: 'ONE', callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
slaveof(host: string | Buffer, port: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
slowlog(subcommand: 'GET', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
slowlog(subcommand: 'GET', count: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
slowlog(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
slowlog(subcommand: 'LEN', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
slowlog(subcommand: 'RESET', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
smembers(key: RedisKey, callback?: Callback<string[]>): Result<string[], Context>;
|
|
smembersBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
smismember(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
smismember(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<number[]>
|
|
]): Result<number[], Context>;
|
|
smismember(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<number[], Context>;
|
|
smismember(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<number[], Context>;
|
|
smove(source: RedisKey, destination: RedisKey, member: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, asc: 'ASC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, desc: 'DESC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, asc: 'ASC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, desc: 'DESC', alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, asc: 'ASC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, desc: 'DESC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, alpha: 'ALPHA', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, asc: 'ASC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, desc: 'DESC', destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey,
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
destinationToken: 'STORE',
|
|
destination: RedisKey
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, asc: 'ASC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, desc: 'DESC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, destinationToken: 'STORE', destination: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, alpha: 'ALPHA', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, asc: 'ASC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, desc: 'DESC', callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<number | unknown[]>
|
|
]): Result<number | unknown[], Context>;
|
|
sort(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, byPatternToken: 'BY', byPattern: string, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort(key: RedisKey, callback?: Callback<number | unknown[]>): Result<number | unknown[], Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, desc: 'DESC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
alpha: 'ALPHA'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
asc: 'ASC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
desc: 'DESC'
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, asc: 'ASC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, desc: 'DESC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
limitToken: 'LIMIT',
|
|
offset: number | string,
|
|
count: number | string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, asc: 'ASC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, desc: 'DESC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
byPatternToken: 'BY',
|
|
byPattern: string,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, alpha: 'ALPHA', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, asc: 'ASC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, desc: 'DESC', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sort_ro(...args: [
|
|
key: RedisKey,
|
|
getPatternToken: 'GET',
|
|
...getPatterns: (string)[]
|
|
]): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, byPatternToken: 'BY', byPattern: string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sort_ro(key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
spop(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
spopBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
spop(key: RedisKey, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
spopBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
spublish(shardchannel: string | Buffer, message: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
srandmember(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
srandmemberBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
srandmember(key: RedisKey, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
srandmemberBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
srem(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
srem(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
srem(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
srem(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
sscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
sscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
sscan(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
sscanBuffer(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
sscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
sscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
sscan(key: RedisKey, cursor: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
sscanBuffer(key: RedisKey, cursor: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
ssubscribe(...args: [
|
|
...shardchannels: (string | Buffer)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
ssubscribe(...args: [
|
|
...shardchannels: (string | Buffer)[]
|
|
]): Result<unknown, Context>;
|
|
strlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
subscribe(...args: [
|
|
...channels: (string | Buffer)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
subscribe(...args: [
|
|
...channels: (string | Buffer)[]
|
|
]): Result<unknown, Context>;
|
|
substr(key: RedisKey, start: number | string, end: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sunion(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
sunionBuffer(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
sunion(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
sunionBuffer(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
sunion(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
sunionBuffer(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
sunion(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
sunionBuffer(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
approx: 'APPROX',
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
approx: 'APPROX',
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
approx: 'APPROX',
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
approx: 'APPROX',
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
approx: 'APPROX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
approx: 'APPROX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
approx: 'APPROX'
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
approx: 'APPROX'
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sunioncard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sunionstore(...args: [
|
|
destination: RedisKey,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunionstore(...args: [
|
|
destination: RedisKey,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
sunionstore(...args: [
|
|
destination: RedisKey,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sunionstore(...args: [
|
|
destination: RedisKey,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
sunsubscribe(callback?: Callback<unknown>): Result<unknown, Context>;
|
|
sunsubscribe(...args: [
|
|
...shardchannels: (string | Buffer)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
sunsubscribe(...args: [
|
|
...shardchannels: (string | Buffer)[]
|
|
]): Result<unknown, Context>;
|
|
swapdb(index1: number | string, index2: number | string, callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
sync(callback?: Callback<unknown>): Result<unknown, Context>;
|
|
time(callback?: Callback<number[]>): Result<number[], Context>;
|
|
touch(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
touch(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
touch(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
touch(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
ttl(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
type(key: RedisKey, callback?: Callback<string>): Result<string, Context>;
|
|
unlink(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
unlink(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
unlink(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
unlink(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
unsubscribe(callback?: Callback<unknown>): Result<unknown, Context>;
|
|
unsubscribe(...args: [
|
|
...channels: (string | Buffer)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
unsubscribe(...args: [
|
|
...channels: (string | Buffer)[]
|
|
]): Result<unknown, Context>;
|
|
unwatch(callback?: Callback<'OK'>): Result<'OK', Context>;
|
|
vadd(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<number>, Resp3<boolean>, Context>>
|
|
]): Result<RespShape<Resp2<number>, Resp3<boolean>, Context>, Context>;
|
|
vadd(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<number>, Resp3<boolean>, Context>, Context>;
|
|
vcard(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
vdim(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
vemb(key: RedisKey, element: string | Buffer | number, raw: 'RAW', callback?: Callback<RespShape<Resp2<string[] | null>, Resp3<number[] | null>, Context>>): Result<RespShape<Resp2<string[] | null>, Resp3<number[] | null>, Context>, Context>;
|
|
vembBuffer(key: RedisKey, element: string | Buffer | number, raw: 'RAW', callback?: Callback<RespShape<Resp2<Buffer[] | null>, Resp3<number[] | null>, Context>>): Result<RespShape<Resp2<Buffer[] | null>, Resp3<number[] | null>, Context>, Context>;
|
|
vemb(key: RedisKey, element: string | Buffer | number, callback?: Callback<RespShape<Resp2<string[] | null>, Resp3<number[] | null>, Context>>): Result<RespShape<Resp2<string[] | null>, Resp3<number[] | null>, Context>, Context>;
|
|
vembBuffer(key: RedisKey, element: string | Buffer | number, callback?: Callback<RespShape<Resp2<Buffer[] | null>, Resp3<number[] | null>, Context>>): Result<RespShape<Resp2<Buffer[] | null>, Resp3<number[] | null>, Context>, Context>;
|
|
vgetattr(key: RedisKey, element: string | Buffer | number, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
vgetattrBuffer(key: RedisKey, element: string | Buffer | number, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
vinfo(key: RedisKey, callback?: Callback<RespShape<Resp2<(string | number)[] | null>, Resp3<Resp3Map<string | number> | null>, Context>>): Result<RespShape<Resp2<(string | number)[] | null>, Resp3<Resp3Map<string | number> | null>, Context>, Context>;
|
|
vinfoBuffer(key: RedisKey, callback?: Callback<RespShape<Resp2<(Buffer | number)[] | null>, Resp3<Resp3Map<Buffer | number> | null>, Context>>): Result<RespShape<Resp2<(Buffer | number)[] | null>, Resp3<Resp3Map<Buffer | number> | null>, Context>, Context>;
|
|
vismember(key: RedisKey, element: string | Buffer | number, callback?: Callback<RespShape<Resp2<number>, Resp3<boolean>, Context>>): Result<RespShape<Resp2<number>, Resp3<boolean>, Context>, Context>;
|
|
vlinks(key: RedisKey, element: string | Buffer | number, withscores: 'WITHSCORES', callback?: Callback<string[][] | null>): Result<string[][] | null, Context>;
|
|
vlinksBuffer(key: RedisKey, element: string | Buffer | number, withscores: 'WITHSCORES', callback?: Callback<Buffer[][] | null>): Result<Buffer[][] | null, Context>;
|
|
vlinks(key: RedisKey, element: string | Buffer | number, callback?: Callback<string[][] | null>): Result<string[][] | null, Context>;
|
|
vlinksBuffer(key: RedisKey, element: string | Buffer | number, callback?: Callback<Buffer[][] | null>): Result<Buffer[][] | null, Context>;
|
|
vrandmember(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
vrandmemberBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
vrandmember(key: RedisKey, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
vrandmemberBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
vrange(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, callback?: Callback<string[]>): Result<string[], Context>;
|
|
vrangeBuffer(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
vrange(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
vrangeBuffer(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
vrem(key: RedisKey, element: string | Buffer | number, callback?: Callback<RespShape<Resp2<number>, Resp3<boolean>, Context>>): Result<RespShape<Resp2<number>, Resp3<boolean>, Context>, Context>;
|
|
vsetattr(key: RedisKey, element: string | Buffer | number, json: string | Buffer, callback?: Callback<RespShape<Resp2<number>, Resp3<boolean>, Context>>): Result<RespShape<Resp2<number>, Resp3<boolean>, Context>, Context>;
|
|
vsim<T extends RedisValue[]>(...args: [
|
|
key: RedisKey,
|
|
...args: T,
|
|
callback: Callback<VsimReply<T, string, Context>>
|
|
]): Result<VsimReply<T, string, Context>, Context>;
|
|
vsimBuffer<T extends RedisValue[]>(...args: [
|
|
key: RedisKey,
|
|
...args: T,
|
|
callback: Callback<VsimReply<T, Buffer, Context>>
|
|
]): Result<VsimReply<T, Buffer, Context>, Context>;
|
|
vsim<T extends RedisValue[]>(...args: [
|
|
key: RedisKey,
|
|
...args: T
|
|
]): Result<VsimReply<T, string, Context>, Context>;
|
|
vsimBuffer<T extends RedisValue[]>(...args: [
|
|
key: RedisKey,
|
|
...args: T
|
|
]): Result<VsimReply<T, Buffer, Context>, Context>;
|
|
wait(numreplicas: number | string, timeout: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
watch(...args: [
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
watch(...args: [
|
|
keys: (RedisKey)[],
|
|
callback: Callback<'OK'>
|
|
]): Result<'OK', Context>;
|
|
watch(...args: [
|
|
...keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
watch(...args: [
|
|
keys: (RedisKey)[]
|
|
]): Result<'OK', Context>;
|
|
xack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
xadd(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<string | null>
|
|
]): Result<string | null, Context>;
|
|
xaddBuffer(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<Buffer | null>
|
|
]): Result<Buffer | null, Context>;
|
|
xadd(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<string | null, Context>;
|
|
xaddBuffer(...args: [
|
|
key: RedisKey,
|
|
...args: (RedisValue)[]
|
|
]): Result<Buffer | null, Context>;
|
|
xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | Buffer | number, start: string | Buffer | number, countToken: 'COUNT', count: number | string, justid: 'JUSTID', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | Buffer | number, start: string | Buffer | number, justid: 'JUSTID', callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | Buffer | number, start: string | Buffer | number, countToken: 'COUNT', count: number | string, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | Buffer | number, start: string | Buffer | number, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
justid: 'JUSTID',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
lastidToken: 'LASTID',
|
|
lastid: string | Buffer | number
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
justid: 'JUSTID',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
justid: 'JUSTID'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE'
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
unixTimeMillisecondsToken: 'TIME',
|
|
unixTimeMilliseconds: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string,
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
msToken: 'IDLE',
|
|
ms: number | string
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<unknown[]>
|
|
]): Result<unknown[], Context>;
|
|
xclaim(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTime: string | Buffer | number,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<unknown[], Context>;
|
|
xdel(...args: [
|
|
key: RedisKey,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xdel(...args: [
|
|
key: RedisKey,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
keepref: 'KEEPREF',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
keepref: 'KEEPREF',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
delref: 'DELREF',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
delref: 'DELREF',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
acked: 'ACKED',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
acked: 'ACKED',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
xdelex(...args: [
|
|
key: RedisKey,
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, newId: '$', mkstream: 'MKSTREAM', entriesreadToken: 'ENTRIESREAD', entriesread: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, id: string | Buffer | number, mkstream: 'MKSTREAM', entriesreadToken: 'ENTRIESREAD', entriesread: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, newId: '$', entriesreadToken: 'ENTRIESREAD', entriesread: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, newId: '$', mkstream: 'MKSTREAM', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, id: string | Buffer | number, entriesreadToken: 'ENTRIESREAD', entriesread: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, id: string | Buffer | number, mkstream: 'MKSTREAM', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, newId: '$', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATE', key: RedisKey, group: string | Buffer, id: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'CREATECONSUMER', key: RedisKey, group: string | Buffer, consumer: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'DELCONSUMER', key: RedisKey, group: string | Buffer, consumer: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'DESTROY', key: RedisKey, group: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'SETID', key: RedisKey, group: string | Buffer, newId: '$', entriesreadToken: 'ENTRIESREAD', entriesread: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'SETID', key: RedisKey, group: string | Buffer, id: string | Buffer | number, entriesreadToken: 'ENTRIESREAD', entriesread: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'SETID', key: RedisKey, group: string | Buffer, newId: '$', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xgroup(subcommand: 'SETID', key: RedisKey, group: string | Buffer, id: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xinfo(subcommand: 'CONSUMERS', key: RedisKey, group: string | Buffer, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xinfo(subcommand: 'GROUPS', key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xinfo(subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xinfo(subcommand: 'STREAM', key: RedisKey, full: 'FULL', countToken: 'COUNT', count: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xinfo(subcommand: 'STREAM', key: RedisKey, full: 'FULL', callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xinfo(subcommand: 'STREAM', key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
force: 'FORCE'
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE'
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE'
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
force: 'FORCE'
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
countToken: 'RETRYCOUNT',
|
|
count: number | string
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
silent: 'SILENT',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fail: 'FAIL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
xnack(...args: [
|
|
key: RedisKey,
|
|
group: string | Buffer,
|
|
fatal: 'FATAL',
|
|
idsToken: 'IDS',
|
|
numids: number | string,
|
|
...ids: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: 'IDLE', minIdleTime: number | string, start: string | Buffer | number, end: string | Buffer | number, count: number | string, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: 'IDLE', minIdleTime: number | string, start: string | Buffer | number, end: string | Buffer | number, count: number | string, consumer: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xpending(key: RedisKey, group: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xpending(key: RedisKey, group: string | Buffer, start: string | Buffer | number, end: string | Buffer | number, count: number | string, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xpending(key: RedisKey, group: string | Buffer, start: string | Buffer | number, end: string | Buffer | number, count: number | string, consumer: string | Buffer, callback?: Callback<unknown[]>): Result<unknown[], Context>;
|
|
xrange(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
id: string,
|
|
fields: string[]
|
|
][]>): Result<[
|
|
id: string,
|
|
fields: string[]
|
|
][], Context>;
|
|
xrangeBuffer(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]>): Result<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][], Context>;
|
|
xrange(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, callback?: Callback<[
|
|
id: string,
|
|
fields: string[]
|
|
][]>): Result<[
|
|
id: string,
|
|
fields: string[]
|
|
][], Context>;
|
|
xrangeBuffer(key: RedisKey, start: string | Buffer | number, end: string | Buffer | number, callback?: Callback<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]>): Result<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][], Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xread(...args: [
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadBuffer(...args: [
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
noack: 'NOACK',
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
minIdleTimeToken: 'CLAIM',
|
|
minIdleTime: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
millisecondsToken: 'BLOCK',
|
|
milliseconds: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxsizeToken: 'MAXSIZE',
|
|
maxsize: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
maxcountToken: 'MAXCOUNT',
|
|
maxcount: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[],
|
|
callback: Callback<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>>
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroup(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: string,
|
|
items: [
|
|
id: string,
|
|
fields: string[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: string,
|
|
fields: string[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xreadgroupBuffer(...args: [
|
|
groupBlockToken: 'GROUP',
|
|
group: string | Buffer,
|
|
consumer: string | Buffer,
|
|
streamsToken: 'STREAMS',
|
|
...args: (RedisValue)[]
|
|
]): Result<RespShape<Resp2<[
|
|
key: Buffer,
|
|
items: [
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]
|
|
][] | null>, Resp3<Resp3Map<[
|
|
id: Buffer,
|
|
fields: Buffer[] | null
|
|
][]> | null>, Context>, Context>;
|
|
xrevrange(key: RedisKey, end: string | Buffer | number, start: string | Buffer | number, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
id: string,
|
|
fields: string[]
|
|
][]>): Result<[
|
|
id: string,
|
|
fields: string[]
|
|
][], Context>;
|
|
xrevrangeBuffer(key: RedisKey, end: string | Buffer | number, start: string | Buffer | number, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]>): Result<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][], Context>;
|
|
xrevrange(key: RedisKey, end: string | Buffer | number, start: string | Buffer | number, callback?: Callback<[
|
|
id: string,
|
|
fields: string[]
|
|
][]>): Result<[
|
|
id: string,
|
|
fields: string[]
|
|
][], Context>;
|
|
xrevrangeBuffer(key: RedisKey, end: string | Buffer | number, start: string | Buffer | number, callback?: Callback<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][]>): Result<[
|
|
id: Buffer,
|
|
fields: Buffer[]
|
|
][], Context>;
|
|
xsetid(key: RedisKey, lastId: string | Buffer | number, entriesAddedToken: 'ENTRIESADDED', entriesAdded: number | string, maxDeletedIdToken: 'MAXDELETEDID', maxDeletedId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xsetid(key: RedisKey, lastId: string | Buffer | number, maxDeletedIdToken: 'MAXDELETEDID', maxDeletedId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xsetid(key: RedisKey, lastId: string | Buffer | number, entriesAddedToken: 'ENTRIESADDED', entriesAdded: number | string, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xsetid(key: RedisKey, lastId: string | Buffer | number, callback?: Callback<unknown>): Result<unknown, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', equal: '=', threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', approximately: '~', threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, keepref: 'KEEPREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, delref: 'DELREF', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, acked: 'ACKED', callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, countToken: 'LIMIT', count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', equal: '=', threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', approximately: '~', threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, maxlen: 'MAXLEN', threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
xtrim(key: RedisKey, minid: 'MINID', threshold: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
gt: 'GT',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
lt: 'LT',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
gt: 'GT',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
lt: 'LT',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zaddBuffer(...args: [
|
|
key: RedisKey,
|
|
incr: 'INCR',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
ch: 'CH',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
gt: 'GT',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
lt: 'LT',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
nx: 'NX',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
xx: 'XX',
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zadd(...args: [
|
|
key: RedisKey,
|
|
...data: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zcard(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
|
|
zcount(key: RedisKey, min: number | string, max: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
zdiff(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
zdiffBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
zdiffstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zdiffstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zdiffstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zdiffstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zincrby(key: RedisKey, increment: number | string, member: string | Buffer | number, callback?: Callback<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>>): Result<RespShape<Resp2<string>, Resp3<Resp3Double<string>>, Context>, Context>;
|
|
zincrbyBuffer(key: RedisKey, increment: number | string, member: string | Buffer | number, callback?: Callback<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>>): Result<RespShape<Resp2<Buffer>, Resp3<Resp3Double<Buffer>>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zinter(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<string[], Context>;
|
|
zinterBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<Buffer[], Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string,
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
limitToken: 'LIMIT',
|
|
limit: number | string
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zintercard(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zinterstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<number, Context>;
|
|
zlexcount(key: RedisKey, min: string | Buffer | number, max: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string,
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
countToken: 'COUNT',
|
|
count: number | string
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
min: 'MIN'
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
min: 'MIN'
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX',
|
|
callback: Callback<unknown>
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
max: 'MAX'
|
|
]): Result<unknown, Context>;
|
|
zmpop(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
max: 'MAX'
|
|
]): Result<unknown, Context>;
|
|
zmscore(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<(string | null)[]>, Resp3<(Resp3Double<string> | null)[]>, Context>>
|
|
]): Result<RespShape<Resp2<(string | null)[]>, Resp3<(Resp3Double<string> | null)[]>, Context>, Context>;
|
|
zmscoreBuffer(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<(Buffer | null)[]>, Resp3<(Resp3Double<Buffer> | null)[]>, Context>>
|
|
]): Result<RespShape<Resp2<(Buffer | null)[]>, Resp3<(Resp3Double<Buffer> | null)[]>, Context>, Context>;
|
|
zmscore(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<(string | null)[]>, Resp3<(Resp3Double<string> | null)[]>, Context>>
|
|
]): Result<RespShape<Resp2<(string | null)[]>, Resp3<(Resp3Double<string> | null)[]>, Context>, Context>;
|
|
zmscoreBuffer(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<RespShape<Resp2<(Buffer | null)[]>, Resp3<(Resp3Double<Buffer> | null)[]>, Context>>
|
|
]): Result<RespShape<Resp2<(Buffer | null)[]>, Resp3<(Resp3Double<Buffer> | null)[]>, Context>, Context>;
|
|
zmscore(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<(string | null)[]>, Resp3<(Resp3Double<string> | null)[]>, Context>, Context>;
|
|
zmscoreBuffer(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<(Buffer | null)[]>, Resp3<(Resp3Double<Buffer> | null)[]>, Context>, Context>;
|
|
zmscore(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<(string | null)[]>, Resp3<(Resp3Double<string> | null)[]>, Context>, Context>;
|
|
zmscoreBuffer(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<RespShape<Resp2<(Buffer | null)[]>, Resp3<(Resp3Double<Buffer> | null)[]>, Context>, Context>;
|
|
zpopmax(key: RedisKey, callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | [
|
|
]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | [
|
|
]>, Context>, Context>;
|
|
zpopmaxBuffer(key: RedisKey, callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | [
|
|
]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | [
|
|
]>, Context>, Context>;
|
|
zpopmax(key: RedisKey, count: number | string, callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zpopmaxBuffer(key: RedisKey, count: number | string, callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zpopmin(key: RedisKey, callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | [
|
|
]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
] | [
|
|
]>, Context>, Context>;
|
|
zpopminBuffer(key: RedisKey, callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | [
|
|
]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
] | [
|
|
]>, Context>, Context>;
|
|
zpopmin(key: RedisKey, count: number | string, callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zpopminBuffer(key: RedisKey, count: number | string, callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrandmember(key: RedisKey, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrandmemberBuffer(key: RedisKey, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrandmember(key: RedisKey, callback?: Callback<string | null>): Result<string | null, Context>;
|
|
zrandmemberBuffer(key: RedisKey, callback?: Callback<Buffer | null>): Result<Buffer | null, Context>;
|
|
zrandmember(key: RedisKey, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrandmemberBuffer(key: RedisKey, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, limitToken: 'LIMIT', offset: number | string, count: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', rev: 'REV', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', rev: 'REV', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, rev: 'REV', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, byscore: 'BYSCORE', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, bylex: 'BYLEX', callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrange(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangeBuffer(key: RedisKey, start: string | Buffer | number, stop: string | Buffer, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrangebylex(key: RedisKey, min: string | Buffer | number, max: string | Buffer | number, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangebylexBuffer(key: RedisKey, min: string | Buffer | number, max: string | Buffer | number, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrangebylex(key: RedisKey, min: string | Buffer | number, max: string | Buffer | number, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangebylexBuffer(key: RedisKey, min: string | Buffer | number, max: string | Buffer | number, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrangebyscore(key: RedisKey, min: number | string, max: number | string, withscores: 'WITHSCORES', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangebyscoreBuffer(key: RedisKey, min: number | string, max: number | string, withscores: 'WITHSCORES', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrangebyscore(key: RedisKey, min: number | string, max: number | string, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangebyscoreBuffer(key: RedisKey, min: number | string, max: number | string, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrangebyscore(key: RedisKey, min: number | string, max: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrangebyscoreBuffer(key: RedisKey, min: number | string, max: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrangebyscore(key: RedisKey, min: number | string, max: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrangebyscoreBuffer(key: RedisKey, min: number | string, max: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, byscore: 'BYSCORE', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, bylex: 'BYLEX', rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, rev: 'REV', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, byscore: 'BYSCORE', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, byscore: 'BYSCORE', rev: 'REV', callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, bylex: 'BYLEX', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, bylex: 'BYLEX', rev: 'REV', callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, rev: 'REV', callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, byscore: 'BYSCORE', callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, bylex: 'BYLEX', callback?: Callback<number>): Result<number, Context>;
|
|
zrangestore(dst: RedisKey, src: RedisKey, min: string | Buffer | number, max: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
zrank(key: RedisKey, member: string | Buffer | number, withscore: 'WITHSCORE', callback?: Callback<RespShape<Resp2<[
|
|
rank: number,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>>): Result<RespShape<Resp2<[
|
|
rank: number,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
zrankBuffer(key: RedisKey, member: string | Buffer | number, withscore: 'WITHSCORE', callback?: Callback<RespShape<Resp2<[
|
|
rank: number,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>>): Result<RespShape<Resp2<[
|
|
rank: number,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
zrank(key: RedisKey, member: string | Buffer | number, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
zrem(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zrem(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zrem(...args: [
|
|
key: RedisKey,
|
|
...members: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zrem(...args: [
|
|
key: RedisKey,
|
|
members: (string | Buffer | number)[]
|
|
]): Result<number, Context>;
|
|
zremrangebylex(key: RedisKey, min: string | Buffer | number, max: string | Buffer | number, callback?: Callback<number>): Result<number, Context>;
|
|
zremrangebyrank(key: RedisKey, start: number | string, stop: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zremrangebyscore(key: RedisKey, min: number | string, max: number | string, callback?: Callback<number>): Result<number, Context>;
|
|
zrevrange(key: RedisKey, start: number | string, stop: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrevrangeBuffer(key: RedisKey, start: number | string, stop: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrevrange(key: RedisKey, start: number | string, stop: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrevrangeBuffer(key: RedisKey, start: number | string, stop: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrevrangebylex(key: RedisKey, max: string | Buffer | number, min: string | Buffer | number, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrevrangebylexBuffer(key: RedisKey, max: string | Buffer | number, min: string | Buffer | number, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrevrangebylex(key: RedisKey, max: string | Buffer | number, min: string | Buffer | number, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrevrangebylexBuffer(key: RedisKey, max: string | Buffer | number, min: string | Buffer | number, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrevrangebyscore(key: RedisKey, max: number | string, min: number | string, withscores: 'WITHSCORES', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrevrangebyscoreBuffer(key: RedisKey, max: number | string, min: number | string, withscores: 'WITHSCORES', limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrevrangebyscore(key: RedisKey, max: number | string, min: number | string, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrevrangebyscoreBuffer(key: RedisKey, max: number | string, min: number | string, limitToken: 'LIMIT', offset: number | string, count: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrevrangebyscore(key: RedisKey, max: number | string, min: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zrevrangebyscoreBuffer(key: RedisKey, max: number | string, min: number | string, withscores: 'WITHSCORES', callback?: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zrevrangebyscore(key: RedisKey, max: number | string, min: number | string, callback?: Callback<string[]>): Result<string[], Context>;
|
|
zrevrangebyscoreBuffer(key: RedisKey, max: number | string, min: number | string, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
|
|
zrevrank(key: RedisKey, member: string | Buffer | number, withscore: 'WITHSCORE', callback?: Callback<RespShape<Resp2<[
|
|
rank: number,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>>): Result<RespShape<Resp2<[
|
|
rank: number,
|
|
score: string
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<string>
|
|
] | null>, Context>, Context>;
|
|
zrevrankBuffer(key: RedisKey, member: string | Buffer | number, withscore: 'WITHSCORE', callback?: Callback<RespShape<Resp2<[
|
|
rank: number,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>>): Result<RespShape<Resp2<[
|
|
rank: number,
|
|
score: Buffer
|
|
] | null>, Resp3<[
|
|
rank: number,
|
|
score: Resp3Double<Buffer>
|
|
] | null>, Context>, Context>;
|
|
zrevrank(key: RedisKey, member: string | Buffer | number, callback?: Callback<number | null>): Result<number | null, Context>;
|
|
zscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
zscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
zscan(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
zscanBuffer(key: RedisKey, cursor: number | string, countToken: 'COUNT', count: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
zscan(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
zscanBuffer(key: RedisKey, cursor: number | string, patternToken: 'MATCH', pattern: string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
zscan(key: RedisKey, cursor: number | string, callback?: Callback<[
|
|
cursor: string,
|
|
elements: string[]
|
|
]>): Result<[
|
|
cursor: string,
|
|
elements: string[]
|
|
], Context>;
|
|
zscanBuffer(key: RedisKey, cursor: number | string, callback?: Callback<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
]>): Result<[
|
|
cursor: Buffer,
|
|
elements: Buffer[]
|
|
], Context>;
|
|
zscore(key: RedisKey, member: string | Buffer | number, callback?: Callback<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>>): Result<RespShape<Resp2<string | null>, Resp3<Resp3Double<string> | null>, Context>, Context>;
|
|
zscoreBuffer(key: RedisKey, member: string | Buffer | number, callback?: Callback<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>>): Result<RespShape<Resp2<Buffer | null>, Resp3<Resp3Double<Buffer> | null>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES',
|
|
callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>>
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<string[]>, Resp3<[
|
|
member: string,
|
|
score: Resp3Double<string>
|
|
][]>, Context>, Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
withscores: 'WITHSCORES'
|
|
]): Result<RespShape<Resp2<Buffer[]>, Resp3<[
|
|
member: Buffer,
|
|
score: Resp3Double<Buffer>
|
|
][]>, Context>, Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<string[]>
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<Buffer[]>
|
|
]): Result<Buffer[], Context>;
|
|
zunion(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<string[], Context>;
|
|
zunionBuffer(...args: [
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<Buffer[], Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
sum: 'SUM'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
min: 'MIN'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
max: 'MAX'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT',
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
aggregate: 'AGGREGATE',
|
|
count: 'COUNT'
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
keys: (RedisKey)[]
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[],
|
|
callback: Callback<number>
|
|
]): Result<number, Context>;
|
|
zunionstore(...args: [
|
|
destination: RedisKey,
|
|
numkeys: number | string,
|
|
...args: (RedisValue)[]
|
|
]): Result<number, Context>;
|
|
}
|
|
|
|
type RedisKey = string | Buffer;
|
|
|
|
interface RedisLikeClient {
|
|
setNX(key: string, value: string, ttlSec: number): Promise<boolean>;
|
|
set(key: string, value: string, ttlSec: number): Promise<void>;
|
|
get(key: string): Promise<string | null>;
|
|
expire(key: string, ttlSec: number): Promise<void>;
|
|
exists(key: string): Promise<boolean>;
|
|
del(keys: string[]): Promise<void>;
|
|
xAdd(key: string, fields: Record<string, string | Uint8Array>): Promise<string>;
|
|
xRange(key: string, start: string, end: string): Promise<Array<{
|
|
id: string;
|
|
fields: Record<string, string | Uint8Array>;
|
|
}>>;
|
|
pipeline(commands: readonly PipelineCommand[]): Promise<void>;
|
|
}
|
|
|
|
type RedisOptions = CommonRedisOptions & SentinelConnectionOptions & StandaloneConnectionOptions;
|
|
|
|
type RedisResumableStreamStoreOptions = {
|
|
readonly keyPrefix?: string;
|
|
readonly defaultTtlMs?: number;
|
|
readonly pollIntervalMs?: number;
|
|
readonly maxChunkBytes?: number;
|
|
};
|
|
|
|
type RedisStatus = "close" | "connect" | "connecting" | "end" | "ready" | "reconnecting" | "wait";
|
|
|
|
type RedisValue = string | Buffer | number;
|
|
|
|
interface ReplyContext {
|
|
protocol?: ProtocolVersion;
|
|
replyMapping?: ReplyMappingMode;
|
|
}
|
|
|
|
type ReplyMappingFromClusterOptions<Current extends ReplyMappingMode, Options> = Options extends {
|
|
redisOptions: {
|
|
replyMapping: infer Mapping;
|
|
};
|
|
} ? Extract<Mapping, ReplyMappingMode> extends never ? Current : Extract<Mapping, ReplyMappingMode> : Current;
|
|
|
|
type ReplyMappingFromOptions<Current extends ReplyMappingMode, Options> = Options extends {
|
|
replyMapping: infer Mapping;
|
|
} ? Extract<Mapping, ReplyMappingMode> extends never ? Current : Extract<Mapping, ReplyMappingMode> : Current;
|
|
|
|
type ReplyMappingMode = "legacy" | "resp3";
|
|
|
|
type ReplyTransformer = (reply: any, context: ReplyTransformerContext) => any;
|
|
|
|
interface ReplyTransformerContext {
|
|
commandName: string;
|
|
protocol: ProtocolVersion;
|
|
replyMapping: ReplyMappingMode;
|
|
}
|
|
|
|
type Resp2<T> = {
|
|
readonly __resp2: T;
|
|
};
|
|
|
|
type Resp3<T> = {
|
|
readonly __resp3: T;
|
|
};
|
|
|
|
type Resp3Double<ReplyString extends string | Buffer = string> = number;
|
|
|
|
type Resp3Map<Value> = Record<string, Value>;
|
|
|
|
type RespShape<Resp2Result extends Resp2<unknown>, Resp3Result extends Resp3<unknown>, Context extends ClientContext> = Context extends {
|
|
mapping: "resp3";
|
|
} ? Resp3Result["__resp3"] : Resp2Result["__resp2"];
|
|
|
|
interface Respondable {
|
|
name: string;
|
|
args: CommandParameter[];
|
|
resolve(result: any): void;
|
|
reject(error: Error): void;
|
|
}
|
|
|
|
type Result<T, Context extends ClientContext> = ResultTypes<T, Context>[Context["type"]];
|
|
|
|
interface ResultTypes<Result, Context> {
|
|
default: Promise<Result>;
|
|
pipeline: ChainableCommander<Context extends {
|
|
mapping: "resp3";
|
|
} ? "resp3" : "resp2">;
|
|
}
|
|
|
|
type ResumableStreamAcquireOptions = {
|
|
readonly ttlMs?: number;
|
|
};
|
|
|
|
interface ResumableStreamContext {
|
|
run(streamId: string, makeStream: () => ReadableStream<Uint8Array>): Promise<ReadableStream<Uint8Array>>;
|
|
resume(streamId: string): Promise<ReadableStream<Uint8Array> | null>;
|
|
requireResume(streamId: string): Promise<ReadableStream<Uint8Array>>;
|
|
status(streamId: string): Promise<ResumableStreamStatus>;
|
|
delete(streamId: string): Promise<void>;
|
|
}
|
|
|
|
type ResumableStreamContextOptions = {
|
|
readonly store: ResumableStreamStore;
|
|
readonly ttlMs?: number;
|
|
readonly waitUntil?: (promise: Promise<unknown>) => void;
|
|
readonly onAcquire?: (streamId: string, role: ResumableStreamRole) => void;
|
|
readonly onAppend?: (streamId: string, byteLength: number) => void;
|
|
readonly onFinalize?: (streamId: string, status: "done" | "error", error?: string) => void;
|
|
readonly onError?: (streamId: string, error: unknown) => void;
|
|
};
|
|
|
|
type ResumableStreamEntry = {
|
|
readonly cursor: string;
|
|
readonly chunk: Uint8Array;
|
|
};
|
|
|
|
declare class ResumableStreamError extends Error {
|
|
readonly code: ResumableStreamErrorCode;
|
|
constructor(code: ResumableStreamErrorCode, message: string);
|
|
}
|
|
|
|
type ResumableStreamErrorCode = "exists" | "finalized" | "invalid-id" | "missing";
|
|
|
|
type ResumableStreamRole = "consumer" | "producer";
|
|
|
|
type ResumableStreamStatus = "done" | "error" | "missing" | "streaming";
|
|
|
|
interface ResumableStreamStore {
|
|
acquire(streamId: string, options?: ResumableStreamAcquireOptions): Promise<ResumableStreamRole>;
|
|
append(streamId: string, chunk: Uint8Array): Promise<void>;
|
|
finalize(streamId: string, status: "done" | "error", error?: string): Promise<void>;
|
|
read(streamId: string, cursor: string, signal: AbortSignal): AsyncIterable<ResumableStreamEntry>;
|
|
status(streamId: string): Promise<ResumableStreamStatus>;
|
|
delete(streamId: string): Promise<void>;
|
|
}
|
|
|
|
type RetryStrategy = ((times: number) => number | void | null) | null | undefined;
|
|
|
|
type SSEEvent = {
|
|
event?: string;
|
|
data: string;
|
|
id?: string;
|
|
retry?: number;
|
|
};
|
|
|
|
declare class SSEEventDecoder {
|
|
#private;
|
|
constructor(options?: {
|
|
trailing?: "dispatch" | "drop";
|
|
});
|
|
push(text: string): SSEEvent[];
|
|
flush(): SSEEvent | null;
|
|
}
|
|
|
|
declare class ScanStream extends Readable {
|
|
#private;
|
|
constructor(opt: Options);
|
|
_read(): void;
|
|
close(): void;
|
|
}
|
|
|
|
interface ScanStreamOptions {
|
|
match?: string;
|
|
type?: string;
|
|
count?: number;
|
|
noValues?: boolean;
|
|
}
|
|
|
|
interface SentinelAddress {
|
|
port: number;
|
|
host: string;
|
|
family?: number;
|
|
}
|
|
|
|
interface SentinelConnectionOptions {
|
|
name?: string | undefined;
|
|
role?: "master" | "slave" | undefined;
|
|
tls?: ConnectionOptions | undefined;
|
|
sentinelUsername?: string | undefined;
|
|
sentinelPassword?: string | undefined;
|
|
sentinels?: Array<Partial<SentinelAddress>> | undefined;
|
|
path?: string | undefined;
|
|
family?: number | undefined;
|
|
sentinelRetryStrategy?: ((retryAttempts: number) => number | void | null) | undefined;
|
|
sentinelReconnectStrategy?: ((retryAttempts: number) => number | void | null) | undefined;
|
|
preferredSlaves?: PreferredSlaves | undefined;
|
|
connectTimeout?: number | undefined;
|
|
disconnectTimeout?: number | undefined;
|
|
sentinelCommandTimeout?: number | undefined;
|
|
enableTLSForSentinelMode?: boolean | undefined;
|
|
sentinelTLS?: ConnectionOptions | undefined;
|
|
natMap?: NatMap | undefined;
|
|
updateSentinels?: boolean | undefined;
|
|
sentinelMaxConnections?: number | undefined;
|
|
failoverDetector?: boolean | undefined;
|
|
protocol?: ProtocolVersion | undefined;
|
|
replyMapping?: ReplyMappingMode | undefined;
|
|
}
|
|
|
|
type SourcePart = {
|
|
type: "source";
|
|
sourceType: "url";
|
|
id: string;
|
|
url: string;
|
|
title?: string;
|
|
parentId?: string;
|
|
};
|
|
|
|
type StandaloneConnectionOptions = Partial<TcpOptions & IpcOptions> & {
|
|
disconnectTimeout?: number | undefined;
|
|
tls?: ConnectionOptions | undefined;
|
|
};
|
|
|
|
declare class SubscriptionSet {
|
|
#private;
|
|
add(set: AddSet, channel: string): void;
|
|
del(set: DelSet, channel: string): void;
|
|
channels(set: AddSet | DelSet): string[];
|
|
isEmpty(): boolean;
|
|
}
|
|
|
|
declare const TOOL_RESPONSE_SYMBOL: unique symbol;
|
|
|
|
type TcpOptions = Pick<TcpNetConnectOpts, "family" | "host" | "port">;
|
|
|
|
type TextPart = {
|
|
type: "text";
|
|
text: string;
|
|
status: TextStatus;
|
|
parentId?: string;
|
|
};
|
|
|
|
type TextStatus = {
|
|
type: "running";
|
|
} | {
|
|
type: "complete";
|
|
reason: "stop" | "unknown";
|
|
} | {
|
|
type: "incomplete";
|
|
reason: "cancelled" | "content-filter" | "length" | "other";
|
|
};
|
|
|
|
type TextStreamController = {
|
|
append(textDelta: string): void;
|
|
close(): void;
|
|
};
|
|
|
|
type ThreadMessageLike = {
|
|
role: "assistant" | "system" | "user";
|
|
content: readonly MessagePartLike[];
|
|
attachments?: readonly AttachmentLike[];
|
|
};
|
|
|
|
type ToToolsJSONSchemaOptions = {
|
|
filter?: (name: string, tool: Tool) => boolean;
|
|
};
|
|
|
|
type Tool<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = FrontendTool<TArgs, TResult> | BackendTool<TArgs, TResult> | HumanTool<TArgs, TResult> | ProviderTool<TArgs, TResult> | McpTool | ToolWithoutType<TArgs, TResult>;
|
|
|
|
type ToolBase<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = {
|
|
streamCall?: ToolStreamCallFunction<TArgs, TResult>;
|
|
display?: ToolDisplay;
|
|
overwrite?: boolean;
|
|
};
|
|
|
|
interface ToolCallArgsReader<TArgs extends Record<string, unknown>> {
|
|
get<PathT extends TypePath<TArgs>>(...fieldPath: PathT): Promise<TypeAtPath<TArgs, PathT>>;
|
|
streamValues<PathT extends TypePath<TArgs>>(...fieldPath: PathT): AsyncIterableStream<DeepPartial<TypeAtPath<TArgs, PathT>>>;
|
|
streamText<PathT extends TypePath<TArgs>>(...fieldPath: PathT): TypeAtPath<TArgs, PathT> extends string & (infer U) ? AsyncIterableStream<U> : never;
|
|
forEach<PathT extends TypePath<TArgs>>(...fieldPath: PathT): NonNullable<TypeAtPath<TArgs, PathT>> extends Array<infer U> ? AsyncIterableStream<U> : never;
|
|
}
|
|
|
|
type ToolCallPart = ToolCallPartWithoutResult | ToolCallPartWithResult;
|
|
|
|
type ToolCallPartBase = {
|
|
type: "tool-call";
|
|
status: ToolCallStatus;
|
|
toolCallId: string;
|
|
toolName: string;
|
|
argsText: string;
|
|
args: ReadonlyJSONObject;
|
|
timing?: ToolCallTiming;
|
|
artifact?: ReadonlyJSONValue;
|
|
result?: ReadonlyJSONValue;
|
|
modelContent?: readonly ToolModelContentPart[];
|
|
isError?: boolean;
|
|
parentId?: string;
|
|
};
|
|
|
|
type ToolCallPartInit = {
|
|
toolCallId?: string;
|
|
toolName: string;
|
|
argsText?: string;
|
|
args?: ReadonlyJSONObject;
|
|
response?: ToolResponseLike<ReadonlyJSONValue>;
|
|
};
|
|
|
|
type ToolCallPartWithResult = ToolCallPartBase & {
|
|
state: "result";
|
|
result: ReadonlyJSONValue;
|
|
artifact?: ReadonlyJSONValue;
|
|
modelContent?: readonly ToolModelContentPart[];
|
|
isError?: boolean;
|
|
};
|
|
|
|
type ToolCallPartWithoutResult = ToolCallPartBase & {
|
|
state: "call" | "partial-call";
|
|
result?: undefined;
|
|
modelContent?: undefined;
|
|
};
|
|
|
|
interface ToolCallReader<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> {
|
|
args: ToolCallArgsReader<TArgs>;
|
|
response: ToolCallResponseReader<TResult>;
|
|
result: {
|
|
get: () => Promise<TResult>;
|
|
};
|
|
}
|
|
|
|
interface ToolCallResponseReader<TResult> {
|
|
get: () => Promise<ToolResponse<TResult>>;
|
|
}
|
|
|
|
type ToolCallStatus = {
|
|
type: "running";
|
|
isArgsComplete: boolean;
|
|
} | {
|
|
type: "requires-action";
|
|
reason: "tool-call-result";
|
|
} | {
|
|
type: "complete";
|
|
reason: "stop" | "unknown";
|
|
} | {
|
|
type: "incomplete";
|
|
reason: "cancelled" | "content-filter" | "length" | "other";
|
|
};
|
|
|
|
type ToolCallStreamController = {
|
|
argsText: TextStreamController;
|
|
setResponse(response: ToolResponseLike<ReadonlyJSONValue>): void;
|
|
close(): void;
|
|
};
|
|
|
|
type ToolCallTiming = {
|
|
readonly startedAt: number;
|
|
readonly completedAt?: number;
|
|
};
|
|
|
|
type ToolCallback = (toolCall: {
|
|
toolCallId: string;
|
|
toolName: string;
|
|
args: ReadonlyJSONObject;
|
|
}) => Promise<ToolResponse<ReadonlyJSONValue>> | ToolResponse<ReadonlyJSONValue> | undefined;
|
|
|
|
type ToolDeclaration<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = FrontendTool<TArgs, TResult> | BackendToolDeclaration<TArgs, TResult> | HumanTool<TArgs, TResult> | ProviderTool<TArgs, TResult> | McpTool | ToolWithoutType<TArgs, TResult>;
|
|
|
|
type ToolDisplay = "inline" | "standalone";
|
|
|
|
type ToolExecuteFunction<TArgs, TResult> = (args: TArgs, context: ToolExecutionContext) => TResult | Promise<TResult>;
|
|
|
|
type ToolExecutionContext = {
|
|
toolCallId: string;
|
|
abortSignal: AbortSignal;
|
|
human: (payload: unknown) => Promise<unknown>;
|
|
};
|
|
|
|
type ToolExecutionOptions = {
|
|
execute: ToolCallback;
|
|
streamCall: ToolStreamCallback;
|
|
onExecutionStart?: ((toolCallId: string, toolName: string) => void) | undefined;
|
|
onExecutionEnd?: ((toolCallId: string, toolName: string) => void) | undefined;
|
|
};
|
|
|
|
declare class ToolExecutionStream extends PipeableTransformStream<AssistantStreamChunk, AssistantStreamChunk> {
|
|
constructor(options: ToolExecutionOptions);
|
|
}
|
|
|
|
type ToolJSONSchema = {
|
|
description?: string;
|
|
parameters: JSONSchema7;
|
|
providerOptions?: ProviderOptions;
|
|
};
|
|
|
|
type ToolModelContentPart = {
|
|
readonly type: "text";
|
|
readonly text: string;
|
|
} | {
|
|
readonly type: "file";
|
|
readonly data: string;
|
|
readonly mediaType: string;
|
|
readonly filename?: string;
|
|
};
|
|
|
|
type ToolModelOutputFunction<TArgs, TResult> = (options: {
|
|
toolCallId: string;
|
|
input: TArgs;
|
|
output: TResult;
|
|
}) => readonly ToolModelContentPart[] | Promise<readonly ToolModelContentPart[]>;
|
|
|
|
declare class ToolResponse<TResult> {
|
|
get [TOOL_RESPONSE_SYMBOL](): boolean;
|
|
readonly artifact?: ReadonlyJSONValue;
|
|
readonly result: TResult;
|
|
readonly isError: boolean;
|
|
readonly modelContent?: readonly ToolModelContentPart[];
|
|
readonly messages?: ReadonlyJSONValue;
|
|
constructor(options: ToolResponseLike<TResult>);
|
|
static [Symbol.hasInstance](obj: unknown): obj is ToolResponse<ReadonlyJSONValue>;
|
|
static toResponse(result: any | ToolResponse<any>): ToolResponse<any>;
|
|
}
|
|
|
|
type ToolResponseLike<TResult> = {
|
|
result: TResult;
|
|
artifact?: ReadonlyJSONValue | undefined;
|
|
isError?: boolean | undefined;
|
|
modelContent?: readonly ToolModelContentPart[] | undefined;
|
|
messages?: ReadonlyJSONValue | undefined;
|
|
};
|
|
|
|
type ToolResultStreamOptions = {
|
|
onExecutionStart?: (toolCallId: string, toolName: string) => void;
|
|
onExecutionEnd?: (toolCallId: string, toolName: string) => void;
|
|
};
|
|
|
|
type ToolStreamCallFunction<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = (reader: ToolCallReader<TArgs, TResult>, context: ToolExecutionContext) => void;
|
|
|
|
type ToolStreamCallback = <TArgs extends ReadonlyJSONObject = ReadonlyJSONObject, TResult extends ReadonlyJSONValue = ReadonlyJSONValue>(toolCall: {
|
|
reader: ToolCallReader<TArgs, TResult>;
|
|
toolCallId: string;
|
|
toolName: string;
|
|
}) => void;
|
|
|
|
type ToolWithoutType<TArgs extends Record<string, unknown> = Record<string, unknown>, TResult = unknown> = (Omit<FrontendTool<TArgs, TResult>, "type"> | Omit<BackendTool<TArgs, TResult>, "type"> | Omit<HumanTool<TArgs, TResult>, "type"> | Omit<ProviderTool<TArgs, TResult>, "type">) & {
|
|
type?: undefined;
|
|
};
|
|
|
|
interface Transaction<Mapping extends "resp2" | "resp3" = "resp2"> {
|
|
pipeline(commands?: unknown[][]): ChainableCommander<Mapping>;
|
|
multi(options: {
|
|
pipeline: false;
|
|
}): Promise<"OK">;
|
|
multi(): ChainableCommander<Mapping>;
|
|
multi(options: {
|
|
pipeline: true;
|
|
}): ChainableCommander<Mapping>;
|
|
multi(commands?: unknown[][]): ChainableCommander<Mapping>;
|
|
}
|
|
|
|
type TupleIndex<T extends readonly any[]> = Exclude<keyof T, keyof any[]>;
|
|
|
|
type TypeAtPath<T, P extends readonly any[]> = P extends [
|
|
infer Head,
|
|
...infer Rest
|
|
] ? Head extends keyof T ? TypeAtPath<T[Head], Rest> : never : T;
|
|
|
|
type TypePath<T> = [
|
|
] | (0 extends 1 & T ? any[] : T extends object ? T extends readonly any[] ? number extends T["length"] ? {
|
|
[K in TupleIndex<T>]: [
|
|
AsNumber<K>,
|
|
...TypePath<T[K]>
|
|
];
|
|
}[TupleIndex<T>] : [
|
|
number,
|
|
...TypePath<T[number]>
|
|
] : {
|
|
[K in ObjectKey<T>]: [
|
|
K,
|
|
...TypePath<T[K]>
|
|
];
|
|
}[ObjectKey<T>] : [
|
|
]);
|
|
|
|
type UIMessageStreamChunk = {
|
|
type: "start";
|
|
messageId: string;
|
|
} | {
|
|
type: "text-start";
|
|
id: string;
|
|
} | {
|
|
type: "text-delta";
|
|
textDelta: string;
|
|
} | {
|
|
type: "text-end";
|
|
} | {
|
|
type: "reasoning-start";
|
|
id: string;
|
|
} | {
|
|
type: "reasoning-delta";
|
|
delta: string;
|
|
} | {
|
|
type: "reasoning-end";
|
|
} | {
|
|
type: "source";
|
|
source: {
|
|
sourceType: "url";
|
|
id: string;
|
|
url: string;
|
|
title?: string;
|
|
};
|
|
} | {
|
|
type: "file";
|
|
file: {
|
|
mimeType: string;
|
|
data: string;
|
|
};
|
|
} | {
|
|
type: "tool-call-start";
|
|
id: string;
|
|
toolCallId: string;
|
|
toolName: string;
|
|
} | {
|
|
type: "tool-call-delta";
|
|
argsText: string;
|
|
} | {
|
|
type: "tool-call-end";
|
|
} | {
|
|
type: "tool-result";
|
|
toolCallId: string;
|
|
result: ReadonlyJSONValue;
|
|
isError?: boolean;
|
|
messages?: ReadonlyJSONValue;
|
|
} | {
|
|
type: "start-step";
|
|
messageId?: string;
|
|
} | {
|
|
type: "finish-step";
|
|
finishReason: FinishReason;
|
|
usage: Usage;
|
|
isContinued: boolean;
|
|
} | {
|
|
type: "finish";
|
|
finishReason: FinishReason;
|
|
usage: Usage;
|
|
} | {
|
|
type: "error";
|
|
errorText: string;
|
|
} | UIMessageStreamDataChunk;
|
|
|
|
type UIMessageStreamDataChunk = {
|
|
type: `data-${string}`;
|
|
id?: string;
|
|
data: ReadonlyJSONValue;
|
|
transient?: boolean;
|
|
};
|
|
|
|
declare class UIMessageStreamDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, AssistantStreamChunk> {
|
|
constructor(options?: UIMessageStreamDecoderOptions);
|
|
}
|
|
|
|
type UIMessageStreamDecoderOptions = {
|
|
onData?: (data: {
|
|
type: string;
|
|
name: string;
|
|
data: unknown;
|
|
transient?: boolean;
|
|
}) => void;
|
|
};
|
|
|
|
type Usage = {
|
|
inputTokens: number;
|
|
outputTokens: number;
|
|
};
|
|
|
|
type VsimReply<T extends RedisValue[], V extends string | Buffer, Context extends ClientContext> = Extract<T[number], "WITHATTRIBS"> extends never ? Extract<T[number], "WITHSCORES"> extends never ? V[] : RespShape<Resp2<V[]>, Resp3<Resp3Map<Resp3Double<V>>>, Context> : Extract<T[number], "WITHSCORES"> extends never ? RespShape<Resp2<V[]>, Resp3<Resp3Map<V | null>>, Context> : RespShape<Resp2<V[]>, Resp3<Resp3Map<[
|
|
score: Resp3Double<V>,
|
|
attributes: V | null
|
|
]>>, Context>;
|
|
|
|
type WriteableStream = NetStream | PipelineWriteableStream;
|
|
|
|
declare function asAsyncIterableStream<T>(source: ReadableStream<T>): AsyncIterableStream<T>;
|
|
|
|
declare function createAssistantStream(callback: (controller: AssistantStreamController) => PromiseLike<void> | void, options?: AssistantStreamOptions): AssistantStream;
|
|
|
|
declare function createAssistantStreamController(options?: AssistantStreamOptions): readonly [
|
|
AssistantStream,
|
|
AssistantStreamController
|
|
];
|
|
|
|
declare function createAssistantStreamResponse(callback: (controller: AssistantStreamController) => PromiseLike<void> | void): Response;
|
|
|
|
declare function createInMemoryResumableStreamStore(options?: InMemoryResumableStreamStoreOptions): ResumableStreamStore & {
|
|
dispose: () => void;
|
|
};
|
|
|
|
declare const createInitialMessage: (_param1?: {
|
|
unstable_state?: ReadonlyJSONValue;
|
|
}) => AssistantMessage;
|
|
|
|
declare function createIoredisResumableStreamStore(client: IoRedisLike, options?: RedisResumableStreamStoreOptions): ResumableStreamStore;
|
|
|
|
declare const createObjectStream: (_param2: {
|
|
execute: (controller: {
|
|
readonly abortSignal: AbortSignal;
|
|
enqueue(operations: readonly GorpStreamOperation[]): void;
|
|
}) => void | PromiseLike<void>;
|
|
defaultValue?: ReadonlyJSONValue;
|
|
}) => ReadableStream<GorpStreamChunk>;
|
|
|
|
declare function createRedisResumableStreamStore(client: NodeRedisLike, options?: RedisResumableStreamStoreOptions): ResumableStreamStore;
|
|
|
|
declare function createResumableAssistantStreamResponse(options: CreateResumableAssistantStreamResponseOptions): Promise<Response>;
|
|
|
|
declare function createResumableStreamContext(options: ResumableStreamContextOptions): ResumableStreamContext;
|
|
|
|
declare function createResumeAssistantStreamResponse(options: CreateResumeAssistantStreamResponseOptions): Promise<Response>;
|
|
|
|
declare const fromObjectStreamResponse: (response: Response) => ReadableStream<GorpStreamChunk>;
|
|
|
|
declare const getPartialJsonObjectFieldState: (obj: Record<string, unknown>, fieldPath: (string | number)[]) => FieldState;
|
|
|
|
declare const getPartialJsonObjectMeta: (obj: Record<symbol, unknown>) => PartialJsonObjectMeta | undefined;
|
|
|
|
declare const hasHimportCoordinator: unique symbol;
|
|
|
|
declare namespace entry_resumable_exports {
|
|
export { CreateResumableAssistantStreamResponseOptions, CreateResumeAssistantStreamResponseOptions, InMemoryResumableStreamStoreOptions, RESUMABLE_STREAM_ID_HEADER, RedisLikeClient, RedisResumableStreamStoreOptions, ResumableStreamAcquireOptions, ResumableStreamContext, ResumableStreamContextOptions, ResumableStreamEntry, ResumableStreamError, ResumableStreamErrorCode, ResumableStreamRole, ResumableStreamStatus, ResumableStreamStore, createInMemoryResumableStreamStore, createResumableAssistantStreamResponse, createResumableStreamContext, createResumeAssistantStreamResponse };
|
|
}
|
|
|
|
declare namespace entry_root_exports {
|
|
export { AssistantMessage, AssistantMessageAccumulator, AssistantMessageStream, AssistantMessageTiming, AssistantStream, AssistantStreamChunk, AssistantStreamController, AssistantTransportDecoder, GorpStreamDeltaTracker as AssistantTransportDeltaTracker, AssistantTransportEncoder, AssistantTransportStateOperation, DataPart, DataStreamDecoder, DataStreamEncoder, GenericAssistantMessage, GenericFilePart, GenericMessage, GenericSystemMessage, GenericTextPart, GenericToolCallPart, GenericToolMessage, GenericToolResultPart, GenericUserMessage, McpServerConfig, ObjectStreamChunk, ObjectStreamResponse, PlainTextDecoder, PlainTextEncoder, ProviderOptions, TextStreamController, ToToolsJSONSchemaOptions, Tool, ToolCallReader, ToolCallStreamController, ToolCallTiming, ToolDeclaration, ToolExecutionStream, ToolJSONSchema, ToolModelContentPart, ToolModelOutputFunction, ToolResponse, ToolResponseLike, ToolResultStreamOptions, UIMessageStreamChunk, UIMessageStreamDataChunk, UIMessageStreamDecoder, UIMessageStreamDecoderOptions, createAssistantStream, createAssistantStreamController, createAssistantStreamResponse, createObjectStream, fromObjectStreamResponse, toGenericMessages, toJSONSchema, toPartialJSONSchema, toToolsJSONSchema, createInitialMessage as unstable_createInitialMessage, unstable_runPendingTools, toolResultStream as unstable_toolResultStream };
|
|
}
|
|
|
|
declare namespace entry_resumable_ioredis_exports {
|
|
export { IoRedisLike, createIoredisResumableStreamStore };
|
|
}
|
|
|
|
declare const parsePartialJsonObject: (json: string) => (ReadonlyJSONObject & {
|
|
[PARTIAL_JSON_OBJECT_META_SYMBOL]: PartialJsonObjectMeta;
|
|
}) | undefined;
|
|
|
|
declare namespace entry_resumable_redis_exports {
|
|
export { NodeRedisLike, createRedisResumableStreamStore };
|
|
}
|
|
|
|
declare function toGenericMessages(messages: readonly ThreadMessageLike[]): GenericMessage[];
|
|
|
|
declare function toJSONSchema(schema: StandardSchemaV1 | JSONSchema7): JSONSchema7;
|
|
|
|
declare function toPartialJSONSchema(schema: JSONSchema7): JSONSchema7;
|
|
|
|
declare function toToolsJSONSchema(tools: Record<string, Tool> | undefined, options?: ToToolsJSONSchemaOptions): Record<string, ToolJSONSchema>;
|
|
|
|
declare function toolResultStream(tools: Record<string, Tool> | (() => Record<string, Tool> | undefined) | undefined, abortSignal: AbortSignal | (() => AbortSignal), human: (toolCallId: string, payload: unknown) => Promise<unknown>, options?: ToolResultStreamOptions): ToolExecutionStream;
|
|
|
|
declare function unstable_runPendingTools(message: AssistantMessage, tools: Record<string, Tool> | undefined, abortSignal: AbortSignal, human: (toolCallId: string, payload: unknown) => Promise<unknown>): Promise<AssistantMessage>;
|
|
|
|
declare namespace entry_utils_exports {
|
|
export { AssistantMetaTransformStream, AssistantTransformStream, AsyncIterableStream, ReadonlyJSONArray, ReadonlyJSONObject, ReadonlyJSONValue, SSEEvent, SSEEventDecoder, asAsyncIterableStream, getPartialJsonObjectFieldState, getPartialJsonObjectMeta, parsePartialJsonObject };
|
|
}
|
|
|
|
export { entry_resumable_exports as entry_resumable, entry_resumable_ioredis_exports as entry_resumable_ioredis, entry_resumable_redis_exports as entry_resumable_redis, entry_root_exports as entry_root, entry_utils_exports as entry_utils };
|