js-valkey-server 0.3.0

package/dist/redis-error-C96iHLJ-.d.mts

@@ -0,0 +1,1392 @@
+import { Server } from 'net';
+import { LuaWasmModule, ReplyValue, LoadOptions } from 'lua-redis-wasm';
+
+type RedisFlavor = 'redis' | 'valkey';
+type VersionGate = {
+    redis?: string;
+    valkey?: string;
+};
+type FeatureId = 'expire.conditions' | 'set.get' | 'set.nx-get' | 'set.exat-pxat' | 'command.docs' | 'command.getkeysandflags' | 'acl.dryrun' | 'client.no-evict' | 'client.kill.maxage' | 'client.setinfo' | 'client.setinfo.unknown-subcommand-error' | 'info.multi-section' | 'shutdown.now-force-abort' | 'pubsub.sharded' | 'pubsub.resp3-publish-reply-first' | 'stream.xautoclaim-deleted-ids' | 'bit.byte-bit-range' | 'hscan.novalues' | 'xread.plus-id' | 'cluster.multi-db';
+interface CompatibilityProfile {
+    readonly flavor: RedisFlavor;
+    readonly version: string;
+    readonly versionNum: number;
+    has(feature: FeatureId): boolean;
+}
+type CompatibilitySpec = CompatibilityProfile | {
+    flavor?: RedisFlavor;
+    version?: string;
+} | 'redis-6.2' | 'redis-7.0' | 'redis-7.2' | 'redis-7.4' | 'redis-8.0' | 'valkey-8.0' | 'valkey-9.0';
+declare function parseVersion(version: string): number;
+declare function resolveCompatibilityProfile(spec?: CompatibilitySpec): CompatibilityProfile;
+declare function gateSatisfied(gate: VersionGate, profile: Pick<CompatibilityProfile, 'flavor' | 'versionNum'>): boolean;
+
+type ParseContext = {
+    commandName: string;
+    profile: CompatibilityProfile;
+};
+type ParseNodeResult<TValue> = {
+    value: TValue;
+    nextIndex: number;
+};
+interface CommandSchema<TValue> {
+    parse(input: readonly Buffer[], index: number, ctx: ParseContext): ParseNodeResult<TValue>;
+}
+type InferSchema<TSchema> = TSchema extends CommandSchema<infer TValue> ? TValue : never;
+type SchemaShape = Record<string, CommandSchema<unknown>>;
+type InferShape<TShape extends SchemaShape> = {
+    [K in keyof TShape]: InferSchema<TShape[K]>;
+};
+declare function parseCommandArgs<TArgs>(schema: CommandSchema<TArgs>, input: readonly Buffer[], commandName: string, profile?: CompatibilityProfile): TArgs;
+declare const t: {
+    custom<TValue>(parse: CommandSchema<TValue>["parse"]): CommandSchema<TValue>;
+    key(): CommandSchema<Buffer>;
+    bulk(): CommandSchema<Buffer>;
+    string(): CommandSchema<string>;
+    integer(options?: {
+        min?: number;
+        max?: number;
+    }): CommandSchema<number>;
+    bigInteger(options?: {
+        min?: bigint;
+        max?: bigint;
+    }): CommandSchema<bigint>;
+    float(): CommandSchema<number>;
+    keyword<TKeyword extends string>(expected: TKeyword): CommandSchema<TKeyword>;
+    optional<TValue>(schema: CommandSchema<TValue>): CommandSchema<TValue | undefined>;
+    variadic<TValue>(schema: CommandSchema<TValue>, options?: {
+        min?: number;
+    }): CommandSchema<TValue[]>;
+    object<TShape extends SchemaShape>(shape: TShape): CommandSchema<InferShape<TShape>>;
+    union<TValue>(schemas: readonly CommandSchema<TValue>[]): CommandSchema<TValue>;
+};
+
+type RedisClusterNodeRole = 'master' | 'replica';
+type RedisClusterNode = {
+    id: string;
+    role: RedisClusterNodeRole;
+    host: string;
+    port: number;
+    masterId?: string;
+    slots: Array<[number, number]>;
+};
+declare const REDIS_CLUSTER_SLOT_COUNT = 16384;
+declare class RedisClusterTopology {
+    readonly nodes: readonly RedisClusterNode[];
+    constructor(nodes?: readonly RedisClusterNode[]);
+    calculateSlot(key: Buffer): number;
+    calculateSlotForKeys(keys: readonly Buffer[]): number | null;
+    getNode(id: string): RedisClusterNode | undefined;
+    /**
+     * Returns the master node owning the slot. Replicas are never returned —
+     * MOVED must always direct the client to a master. Returns undefined if
+     * the slot is unassigned.
+     */
+    getSlotOwner(slot: number): RedisClusterNode | undefined;
+    /**
+     * Returns whether the node is the master serving the slot. Replicas never
+     * own slots for routing purposes — keyed commands sent directly to a
+     * replica must redirect to the master via MOVED.
+     */
+    nodeOwnsSlot(nodeId: string, slot: number): boolean;
+    /**
+     * Returns whether a node may serve a readonly command for the slot after the
+     * client enabled Redis Cluster READONLY mode. Masters may serve their own
+     * slots; replicas may serve slots owned by their configured master.
+     */
+    nodeCanServeReadonlySlot(nodeId: string, slot: number): boolean;
+}
+
+type RedisDataTypeName = 'string' | 'hash' | 'list' | 'set' | 'zset' | 'stream';
+type RedisStringData = {
+    type: 'string';
+    value: Buffer;
+};
+type RedisHashData = {
+    type: 'hash';
+    fields: Map<string, RedisHashField>;
+};
+type RedisHashField = {
+    field: Buffer;
+    value: Buffer;
+    expiresAt?: number;
+};
+type RedisListData = {
+    type: 'list';
+    values: Buffer[];
+};
+type RedisSetData = {
+    type: 'set';
+    members: Map<string, Buffer>;
+};
+type RedisSortedSetData = {
+    type: 'zset';
+    members: Map<string, RedisSortedSetMember>;
+};
+type RedisSortedSetMember = {
+    member: Buffer;
+    score: number;
+};
+type StreamId = {
+    ms: bigint;
+    seq: bigint;
+};
+type RedisStreamEntry = {
+    id: StreamId;
+    fields: Buffer[];
+};
+type RedisStreamConsumer = {
+    name: Buffer;
+    seenAt: number;
+    activeAt: number | null;
+};
+type RedisStreamPendingEntry = {
+    id: StreamId;
+    consumerId: string;
+    deliveredAt: number;
+    deliveryCount: number;
+};
+type RedisStreamConsumerGroup = {
+    name: Buffer;
+    lastDeliveredId: StreamId;
+    entriesRead: number | null;
+    consumers: Map<string, RedisStreamConsumer>;
+    pending: Map<string, RedisStreamPendingEntry>;
+};
+type RedisStreamData = {
+    type: 'stream';
+    entries: RedisStreamEntry[];
+    lastId: StreamId;
+    entriesAdded: number;
+    maxDeletedEntryId: StreamId;
+    groups: Map<string, RedisStreamConsumerGroup>;
+};
+type RedisDataValue = RedisStringData | RedisHashData | RedisListData | RedisSetData | RedisSortedSetData | RedisStreamData;
+declare function cloneRedisDataValue(value: RedisDataValue): RedisDataValue;
+declare function createStringData(value: Buffer): RedisStringData;
+declare function createHashData(): RedisHashData;
+declare function createListData(): RedisListData;
+declare function createSetData(): RedisSetData;
+declare function createSortedSetData(): RedisSortedSetData;
+
+type RedisMutationEvent = {
+    type: 'write';
+    database: number;
+    key: Buffer;
+    value: RedisDataValue;
+    expiresAt?: number;
+} | {
+    type: 'delete';
+    database: number;
+    key: Buffer;
+} | {
+    type: 'expire';
+    database: number;
+    key: Buffer;
+    expiresAt: number;
+} | {
+    type: 'persist';
+    database: number;
+    key: Buffer;
+} | {
+    type: 'evict';
+    database: number;
+    key: Buffer;
+} | {
+    type: 'flush';
+    database: number;
+};
+type RedisMutationListener = (event: RedisMutationEvent) => void;
+type Unsubscribe = () => void;
+declare class RedisMutationBus {
+    private readonly globalListeners;
+    private readonly keyListeners;
+    subscribe(listener: RedisMutationListener): Unsubscribe;
+    subscribeKey(key: Buffer, listener: RedisMutationListener): Unsubscribe;
+    emit(event: RedisMutationEvent): void;
+}
+
+type ExpirationState = {
+    kind: 'missing';
+} | {
+    kind: 'persistent';
+} | {
+    kind: 'expires';
+    expiresAt: number;
+};
+type KeyspaceEntry = {
+    key: Buffer;
+    value: RedisDataValue;
+    expiresAt?: number;
+};
+type SetOptions = {
+    expiresAt?: number;
+    keepTtl?: boolean;
+};
+type KeyspaceMutationTracker = {
+    markChanged(): void;
+    markCommitted(): void;
+};
+declare class WrongRedisTypeError extends Error {
+    readonly expected: RedisDataTypeName;
+    readonly actual: RedisDataTypeName;
+    constructor(expected: RedisDataTypeName, actual: RedisDataTypeName);
+}
+declare class RedisKeyspace {
+    private readonly database;
+    private readonly mutations;
+    private readonly entries;
+    constructor(database: number, mutations: RedisMutationBus);
+    get(key: Buffer): RedisDataValue | null;
+    getType(key: Buffer): RedisDataTypeName | null;
+    set(key: Buffer, value: RedisDataValue, options?: SetOptions): void;
+    delete(key: Buffer): boolean;
+    expire(key: Buffer, expiresAt: number): boolean;
+    persist(key: Buffer): boolean;
+    getExpiration(key: Buffer): ExpirationState;
+    update<TValue extends RedisDataValue, TResult>(key: Buffer, expectedType: TValue['type'], createValue: () => TValue, mutator: (value: TValue, tracker: KeyspaceMutationTracker) => TResult): TResult;
+    flush(): void;
+    size(): number;
+    entriesSnapshot(): KeyspaceEntry[];
+    sweepExpired(now?: number): number;
+    private getLiveEntry;
+    private evictIfExpired;
+    private emitWrite;
+}
+
+interface RedisTurnHandle {
+    release(): void;
+    suspend(waitFor: Promise<unknown>): Promise<RedisTurnHandle>;
+}
+interface RedisTurnQueue {
+    waitTurn(): Promise<RedisTurnHandle>;
+}
+declare class SerialTurnQueue implements RedisTurnQueue {
+    private readonly queue;
+    private locked;
+    waitTurn(): Promise<RedisTurnHandle>;
+    private waitTurnInternal;
+    private scheduleNext;
+}
+
+declare class TrackedHashData {
+    private readonly hash;
+    private readonly tracker;
+    constructor(hash: RedisHashData, tracker: KeyspaceMutationTracker);
+    get size(): number;
+    getField(field: Buffer): RedisHashField | undefined;
+    hasField(field: Buffer): boolean;
+    setField(field: Buffer, value: Buffer, options?: {
+        forceDirty?: boolean;
+        keepTtl?: boolean;
+    }): {
+        added: boolean;
+        valueChanged: boolean;
+    };
+    setFieldIfAbsent(field: Buffer, value: Buffer): boolean;
+    deleteField(field: Buffer): boolean;
+    setFieldExpiration(field: Buffer, expiresAt: number): boolean;
+    clearFieldExpiration(field: Buffer): boolean;
+    entries(): IterableIterator<RedisHashField>;
+    private deleteExpiredFields;
+}
+declare class TrackedListData {
+    private readonly list;
+    private readonly tracker;
+    constructor(list: RedisListData, tracker: KeyspaceMutationTracker);
+    get length(): number;
+    pushLeft(values: readonly Buffer[]): number;
+    pushRight(values: readonly Buffer[]): number;
+    pop(side: 'left' | 'right'): Buffer | null;
+    popMany(side: 'left' | 'right', count: number): Buffer[];
+    setAt(index: number, value: Buffer): void;
+    insertRelativeTo(pivot: Buffer, element: Buffer, position: 'before' | 'after'): number;
+    removeMatching(count: number, element: Buffer): number;
+    trim(start: number, stop: number, options?: {
+        forceDirty?: boolean;
+    }): {
+        empty: boolean;
+    };
+}
+declare class TrackedSetData {
+    private readonly set;
+    private readonly tracker;
+    constructor(set: RedisSetData, tracker: KeyspaceMutationTracker);
+    get size(): number;
+    hasMember(member: Buffer): boolean;
+    addMember(member: Buffer): boolean;
+    deleteMember(member: Buffer): boolean;
+    deleteMemberId(hex: string): boolean;
+    randomMemberEntries(): [string, Buffer][];
+    replaceMembers(hexSet: Set<string>, bufferMap: Map<string, Buffer>, options?: {
+        forceDirty?: boolean;
+    }): void;
+}
+declare class TrackedSortedSetData {
+    private readonly zset;
+    private readonly tracker;
+    constructor(zset: RedisSortedSetData, tracker: KeyspaceMutationTracker);
+    get size(): number;
+    getMember(member: Buffer): RedisSortedSetMember | undefined;
+    setScore(member: Buffer, score: number, options?: {
+        forceDirty?: boolean;
+    }): {
+        added: boolean;
+        scoreChanged: boolean;
+    };
+    deleteMember(member: Buffer): boolean;
+    deleteMemberId(hex: string): boolean;
+    entries(): IterableIterator<[string, RedisSortedSetMember]>;
+    replaceMembers(members: Map<string, RedisSortedSetMember>, options?: {
+        forceDirty?: boolean;
+    }): void;
+}
+type StreamDelivery = {
+    id: StreamId;
+    fields: Buffer[] | null;
+};
+type ClaimedEntry = {
+    id: StreamId;
+    fields: Buffer[];
+};
+type AutoClaimedEntry = {
+    id: StreamId;
+    fields: Buffer[] | null;
+};
+type AutoClaimResult = {
+    nextStartId: StreamId;
+    claimed: AutoClaimedEntry[];
+    deleted: StreamId[];
+};
+declare class TrackedStreamData {
+    private readonly stream;
+    private readonly tracker;
+    constructor(stream: RedisStreamData, tracker: KeyspaceMutationTracker);
+    get value(): RedisStreamData;
+    get lastId(): StreamId;
+    appendEntry(id: StreamId, fields: Buffer[]): void;
+    trim(callback: (stream: RedisStreamData) => number): number;
+    deleteEntries(targets: readonly StreamId[], compare: (left: StreamId, right: StreamId) => number, onDelete: (entry: RedisStreamEntry) => void): number;
+    ack(group: RedisStreamConsumerGroup, ids: readonly StreamId[]): number;
+    setId(id: StreamId, options: {
+        entriesAdded: number | null;
+        maxDeletedId: StreamId | null;
+    }): void;
+    setGroupId(group: RedisStreamConsumerGroup, lastDeliveredId: StreamId, entriesRead: number | null): void;
+    readGroup(group: RedisStreamConsumerGroup, consumerName: Buffer, id: StreamId | '>', options: {
+        count: number | null;
+        noack: boolean;
+    }, now: number): StreamDelivery[];
+    claim(group: RedisStreamConsumerGroup, consumerName: Buffer, ids: readonly StreamId[], options: {
+        minIdleMs: number;
+        idleMs: number | null;
+        timeMs: number | null;
+        retryCount: number | null;
+        force: boolean;
+        justId: boolean;
+        lastId: StreamId | null;
+    }, now: number): ClaimedEntry[];
+    autoClaim(group: RedisStreamConsumerGroup, consumerName: Buffer, options: {
+        minIdleMs: number;
+        start: StreamId;
+        count: number;
+        justId: boolean;
+        cleanDeletedEntries: boolean;
+    }, now: number): AutoClaimResult;
+    addGroup(groupId: string, group: RedisStreamConsumerGroup): void;
+    deleteGroup(groupId: string): boolean;
+    addConsumer(group: RedisStreamConsumerGroup, consumerId: string, consumer: RedisStreamConsumer): boolean;
+    deleteConsumer(group: RedisStreamConsumerGroup, consumerId: string): number;
+}
+
+declare class RedisDatabase {
+    readonly id: number;
+    readonly mutations: RedisMutationBus;
+    /**
+     * Per-database serialization turn. All sessions targeting this database
+     * acquire turns from here so writes do not interleave. Sessions on other
+     * databases run on independent queues, which means the mock allows
+     * cross-database parallelism — real Redis is single-threaded across all
+     * databases. Acceptable for a mock; do not rely on cross-database
+     * serialization in tests.
+     */
+    readonly turnQueue: RedisTurnQueue;
+    /**
+     * Name of the command currently executing against this database, set by the
+     * CommandExecutor around `definition.execute`. Keyspace notifications read it
+     * to name write events after the originating command (e.g. LPUSH → `lpush`),
+     * which the mutation bus itself does not carry. `null` outside command
+     * execution.
+     */
+    activeNotifyCommand: string | null;
+    private readonly keyspace;
+    constructor(id: number);
+    get(key: Buffer): RedisDataValue | null;
+    getString(key: Buffer): Buffer | null;
+    getType(key: Buffer): RedisDataValue['type'] | null;
+    set(key: Buffer, value: RedisDataValue, options?: SetOptions): void;
+    setString(key: Buffer, value: Buffer, options?: SetOptions): void;
+    delete(key: Buffer): boolean;
+    expire(key: Buffer, expiresAt: number): boolean;
+    persist(key: Buffer): boolean;
+    getExpiration(key: Buffer): ExpirationState;
+    getHash(key: Buffer): RedisHashData | null;
+    getList(key: Buffer): RedisListData | null;
+    getSet(key: Buffer): RedisSetData | null;
+    getSortedSet(key: Buffer): RedisSortedSetData | null;
+    getStream(key: Buffer): RedisStreamData | null;
+    updateHash<TResult>(key: Buffer, mutator: (hash: TrackedHashData) => TResult): TResult;
+    updateList<TResult>(key: Buffer, mutator: (list: TrackedListData) => TResult): TResult;
+    updateSet<TResult>(key: Buffer, mutator: (set: TrackedSetData) => TResult): TResult;
+    updateSortedSet<TResult>(key: Buffer, mutator: (zset: TrackedSortedSetData) => TResult): TResult;
+    updateStream<TResult>(key: Buffer, mutator: (stream: TrackedStreamData) => TResult): TResult;
+    private getTyped;
+    private updateTyped;
+    flush(): void;
+    size(): number;
+    entriesSnapshot(): KeyspaceEntry[];
+    sweepExpired(now?: number): number;
+    subscribe(listener: RedisMutationListener): Unsubscribe;
+    subscribeKey(key: Buffer, listener: RedisMutationListener): Unsubscribe;
+}
+
+type RedisMonitorCommandEvent = {
+    timestampMs: number;
+    database: number;
+    clientId: string;
+    clientAddress?: string;
+    command: Buffer;
+    args: readonly Buffer[];
+};
+type RedisMonitorCommandListener = (event: RedisMonitorCommandEvent) => void;
+declare class RedisMonitorFeed {
+    private readonly listeners;
+    get subscriberCount(): number;
+    subscribe(listener: RedisMonitorCommandListener): Unsubscribe;
+    publish(event: RedisMonitorCommandEvent): void;
+}
+
+type RedisPubSubMessage = {
+    channel: Buffer;
+    message: Buffer;
+};
+type RedisPubSubPatternMessage = RedisPubSubMessage & {
+    pattern: Buffer;
+};
+type RedisPubSubMessageListener = (message: RedisPubSubMessage) => void;
+type RedisPubSubPatternMessageListener = (message: RedisPubSubPatternMessage) => void;
+declare class RedisPubSubBroker {
+    private readonly channels;
+    private readonly shardChannels;
+    private readonly patterns;
+    subscribe(channel: Buffer, listener: RedisPubSubMessageListener): Unsubscribe;
+    psubscribe(pattern: Buffer, listener: RedisPubSubPatternMessageListener): Unsubscribe;
+    ssubscribe(channel: Buffer, listener: RedisPubSubMessageListener): Unsubscribe;
+    publish(channel: Buffer, message: Buffer): number;
+    spublish(channel: Buffer, message: Buffer): number;
+    channelsMatching(pattern?: Buffer): Buffer[];
+    shardChannelsMatching(pattern?: Buffer): Buffer[];
+    subscriberCount(channel: Buffer): number;
+    shardSubscriberCount(channel: Buffer): number;
+    patternSubscriptionCount(): number;
+}
+
+declare class RedisScriptCache {
+    private readonly scripts;
+    load(script: Buffer): string;
+    get(sha: string): Buffer | null;
+    exists(sha: string): boolean;
+    existsAll(shas: readonly string[]): boolean[];
+    flush(): void;
+    size(): number;
+}
+
+type RedisFunctionDefinition = {
+    name: string;
+    libraryName: string;
+    script: Buffer;
+    flags: string[];
+};
+type RedisFunctionLibrary = {
+    name: string;
+    code: Buffer;
+    functions: RedisFunctionDefinition[];
+};
+declare class RedisFunctionRegistry {
+    private readonly libraries;
+    load(library: RedisFunctionLibrary, replace?: boolean): void;
+    delete(name: string): boolean;
+    clear(): void;
+    list(): RedisFunctionLibrary[];
+    findFunction(name: string): RedisFunctionDefinition | null;
+    dump(): Buffer;
+    restore(payload: Buffer, mode: 'append' | 'flush' | 'replace'): void;
+}
+
+type RedisValue = {
+    kind: 'simple-string';
+    value: string;
+} | {
+    kind: 'bulk-string';
+    value: Buffer | null;
+} | {
+    kind: 'integer';
+    value: number | bigint;
+} | {
+    kind: 'double';
+    value: number;
+} | {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'big-number';
+    value: bigint;
+} | {
+    kind: 'verbatim';
+    format: string;
+    value: Buffer;
+} | {
+    kind: 'array';
+    items: RedisValue[];
+} | {
+    kind: 'set';
+    items: RedisValue[];
+} | {
+    kind: 'map';
+    entries: [RedisValue, RedisValue][];
+} | {
+    kind: 'map-pairs';
+    entries: [RedisValue, RedisValue][];
+} | {
+    kind: 'flat-pairs';
+    entries: [RedisValue, RedisValue][];
+} | {
+    kind: 'push';
+    name: string;
+    items: RedisValue[];
+} | {
+    kind: 'null';
+} | {
+    kind: 'null-array';
+} | {
+    kind: 'error';
+    message: string;
+    code?: string;
+};
+declare const RedisValue: {
+    simpleString: (value: string) => RedisValue;
+    bulkString: (value: Buffer | null) => RedisValue;
+    integer: (value: number | bigint) => RedisValue;
+    double: (value: number) => RedisValue;
+    boolean: (value: boolean) => RedisValue;
+    bigNumber: (value: bigint) => RedisValue;
+    verbatim: (format: string, value: Buffer) => RedisValue;
+    array: (items: RedisValue[]) => RedisValue;
+    set: (items: RedisValue[]) => RedisValue;
+    map: (entries: [RedisValue, RedisValue][]) => RedisValue;
+    mapPairs: (entries: [RedisValue, RedisValue][]) => RedisValue;
+    flatPairs: (entries: [RedisValue, RedisValue][]) => RedisValue;
+    push: (name: string, items: RedisValue[]) => RedisValue;
+    null: () => RedisValue;
+    nullArray: () => RedisValue;
+    error: (message: string, code?: string) => RedisValue;
+};
+
+type LuaReplyValue = ReplyValue;
+declare class RedisLuaRuntime {
+    private readonly hostState;
+    private readonly engine;
+    constructor(module: LuaWasmModule);
+    eval(script: Buffer, keys: readonly Buffer[], args: readonly Buffer[], ctx: RedisExecutionContext, options?: {
+        readOnly?: boolean;
+    }): ReplyValue;
+    private runRedisCommand;
+}
+/**
+ * Override where the Lua WASM module + Emscripten glue are loaded from — e.g. a
+ * CDN URL (`{ modulePath, wasmPath }`) or preloaded bytes (`{ wasmBytes }`).
+ * Affects every runtime created afterwards, so set it once before the first EVAL.
+ * Mainly useful in browser bundles that want the `.wasm` served from a CDN
+ * instead of emitted as a local asset.
+ */
+declare function setLuaWasmLoadOptions(options: LoadOptions): void;
+declare function createRedisLuaRuntime(profile?: CompatibilityProfile): Promise<RedisLuaRuntime>;
+declare function luaReplyToRedisValue(value: ReplyValue): RedisValue;
+
+type RedisServerStateOptions = {
+    databaseCount?: number;
+    clusterTopology?: RedisClusterTopology;
+    monitorFeed?: RedisMonitorFeed;
+    pubsubBroker?: RedisPubSubBroker;
+    scriptCache?: RedisScriptCache;
+    functionRegistry?: RedisFunctionRegistry;
+    /**
+     * Interval for the background active-expiry sweep. Set to `false` to disable
+     * the timer for tests that need full manual control of expiration.
+     */
+    activeExpiryIntervalMs?: number | false;
+    /**
+     * Optional server password (Redis `requirepass`). When set, connections start
+     * unauthenticated and must `AUTH` before running most commands. When unset,
+     * the default user is `nopass` and no authentication is enforced.
+     */
+    requirepass?: string;
+    compatibility?: CompatibilitySpec;
+};
+declare class RedisServerState {
+    readonly databases: RedisDatabase[];
+    readonly scriptCache: RedisScriptCache;
+    readonly monitorFeed: RedisMonitorFeed;
+    readonly pubsubBroker: RedisPubSubBroker;
+    readonly functionRegistry: RedisFunctionRegistry;
+    readonly clusterTopology: RedisClusterTopology;
+    readonly requirepass?: string;
+    readonly profile: CompatibilityProfile;
+    /**
+     * Normalized `notify-keyspace-events` flag string (Redis canonical form, e.g.
+     * `"AKE"`). Empty string disables keyspace notifications. Managed via
+     * CONFIG GET/SET; read by the wired {@link KeyspaceNotifier} on each mutation.
+     */
+    notifyKeyspaceEvents: string;
+    private readonly clientSessions;
+    private activeExpiryTimer;
+    private closed;
+    private luaRuntimePromise;
+    constructor(options?: RedisServerStateOptions);
+    /**
+     * Returns this server's own Lua runtime, created lazily and memoized per
+     * RedisServerState instance. Scoping the runtime here (rather than a
+     * process-wide singleton) keeps each logical node's LuaEngine + script
+     * re-entrancy guard isolated, so concurrent EVALs on independent
+     * server/cluster nodes never collide (issue #130).
+     */
+    getLuaRuntime(): Promise<RedisLuaRuntime>;
+    getDatabase(id: number): RedisDatabase;
+    registerClientSession(session: RedisClientSession): Unsubscribe;
+    getConnectedClients(): readonly RedisClientSession[];
+    /**
+     * Flushes keyspace data only. Redis script cache is server-wide state and
+     * remains intact until SCRIPT FLUSH.
+     */
+    flushAllDatabases(): void;
+    sweepExpired(now?: number): number;
+    close(): void;
+    private startActiveExpiry;
+    private scheduleActiveExpiry;
+    private runActiveExpiryTick;
+    private runActiveExpiry;
+}
+
+type RedisResultOptions = {
+    close?: boolean;
+    disconnect?: boolean;
+    omitReply?: boolean;
+    afterReply?: () => void;
+};
+declare class RedisResult {
+    readonly value: RedisValue;
+    readonly options?: RedisResultOptions | undefined;
+    readonly encoded?: Buffer | undefined;
+    constructor(value: RedisValue, options?: RedisResultOptions | undefined, encoded?: Buffer | undefined);
+    static create(value: RedisValue, options?: RedisResultOptions): RedisResult;
+    static preEncoded(value: RedisValue, encoded: Buffer, options?: RedisResultOptions): RedisResult;
+    static nil(): RedisResult;
+    static ok(): RedisResult;
+    static error(message: string, code?: string): RedisResult;
+}
+
+type RespVersion = 2 | 3;
+type RespEncodeOptions = {
+    version?: RespVersion;
+};
+declare function encodeRedisResult(result: RedisResult, options?: RespEncodeOptions): Buffer;
+declare function encodeRedisValue(value: RedisValue, options?: RespEncodeOptions): Buffer;
+
+type ParkRequest<TValue> = {
+    waitFor: Promise<TValue | null>;
+    timeoutMs?: number;
+    signal: AbortSignal;
+};
+type ParkHandler = <TValue>(request: ParkRequest<TValue>) => Promise<TValue | null>;
+type ClientSessionMode = 'normal' | 'transaction' | 'subscribed';
+type RedisMonitorContext = {
+    readonly disabled?: boolean;
+    readonly defer?: boolean;
+    readonly clientAddress?: string;
+    readonly deferredEvents?: RedisMonitorCommandEvent[];
+};
+interface RedisClientSession {
+    readonly id: string;
+    readonly clientAddress?: string;
+    readonly connectedAtMs: number;
+    readonly selectedDatabase: number;
+    readonly mode: ClientSessionMode;
+    readonly protocolVersion: RespVersion;
+    readonly usesSubscribedReplyMode: boolean;
+    readonly clusterReadOnly: boolean;
+    readonly isAuthenticated: boolean;
+    setAuthenticated(value: boolean): void;
+    setProtocolVersion(version: RespVersion): void;
+    setClusterReadOnly(value: boolean): void;
+    selectDatabase(database: number): void;
+    beginTransaction(): void;
+    queueTransaction(plan: CommandPlan): void;
+    drainTransaction(): CommandPlan[];
+    discardTransaction(): void;
+    markTransactionDirty(): void;
+    isTransactionDirty(): boolean;
+    executeTransaction(plans: readonly CommandPlan[]): Promise<RedisResult>;
+    watch(keys: readonly Buffer[]): void;
+    unwatch(): void;
+    isWatchDirty(): boolean;
+    readonly pubsubChannelCount: number;
+    readonly pubsubShardChannelCount: number;
+    readonly pubsubPatternCount: number;
+    readonly pubsubSubscriptionCount: number;
+    subscribePubSubChannels(channels: readonly Buffer[]): RedisResult[];
+    unsubscribePubSubChannels(channels: readonly Buffer[]): RedisResult[];
+    subscribePubSubShardChannels(channels: readonly Buffer[]): RedisResult[];
+    unsubscribePubSubShardChannels(channels: readonly Buffer[]): RedisResult[];
+    subscribePubSubPatterns(patterns: readonly Buffer[]): RedisResult[];
+    unsubscribePubSubPatterns(patterns: readonly Buffer[]): RedisResult[];
+    resetPubSub(): void;
+    deferPushesUntilAfterReply(): () => void;
+    registerResponseStreamCleanup(cleanup: () => void): () => void;
+    resetResponseStreams(): void;
+    disconnect(reason?: string): void;
+}
+interface RedisExecutionContext {
+    readonly db: RedisDatabase;
+    readonly server: RedisServerState;
+    readonly session: RedisClientSession;
+    readonly executor: CommandExecutor;
+    readonly transactionReplay?: boolean;
+    readonly nodeRole?: RedisClusterNodeRole;
+    readonly monitor?: RedisMonitorContext;
+    readonly signal: AbortSignal;
+    park: ParkHandler;
+}
+declare function createDefaultParkHandler(): ParkHandler;
+declare function createNoopParkHandler(): ParkHandler;
+/**
+ * Park handler for commands replayed inside MULTI/EXEC.
+ *
+ * Blocking commands (BLPOP, BLMOVE, BLMPOP, BZMPOP, XREAD BLOCK, ...) must not
+ * actually block here: real Redis runs them non-blocking inside a transaction
+ * and returns the immediate "nothing happened" result (e.g. BLPOP -> nil). This
+ * resolves `null` straight away — the same timeout sentinel a real park returns
+ * on expiry — so the command takes its non-blocking branch and its `finally`
+ * cleanup (wakeup-subscription teardown) runs.
+ *
+ * Unlike a bare `async () => null`, it still *honors* the park request:
+ *  - it attaches a no-op handler to `request.waitFor`, so a command whose wait
+ *    rejects never surfaces an unhandled promise rejection (mirrors
+ *    {@link createDefaultParkHandler}, which consumes `waitFor`);
+ *  - it rejects with an AbortError if the session signal is already aborted, so
+ *    a transaction aborted mid-EXEC propagates immediately instead of swallowing
+ *    the abort.
+ *
+ * Commands MUST release any wakeup subscription in a `finally` around
+ * `ctx.park(...)`, never by chaining off `waitFor` — a non-blocking park may
+ * resolve without `waitFor` ever settling.
+ */
+declare function createNonBlockingParkHandler(): ParkHandler;
+
+/**
+ * Single-reader stream of server-initiated Redis responses.
+ *
+ * Phase 1 intentionally keeps backpressure out of this interface. A transport
+ * owns the single reader and may pause iteration if its underlying connection
+ * applies backpressure. Implementations should treat a second `frames()` reader
+ * as unsupported unless they document stronger behavior.
+ */
+interface ResponseStream {
+    readonly kind: 'response-stream';
+    readonly closed: Promise<void>;
+    frames(signal: AbortSignal): AsyncIterable<RedisResult>;
+    close(reason?: string): void;
+}
+declare function isResponseStream(value: unknown): value is ResponseStream;
+
+type CommandFlag = 'readonly' | 'write' | 'denyoom' | 'admin' | 'noscript' | 'random' | 'blocking' | 'fast' | 'movablekeys' | 'transaction' | 'pubsub' | 'subscribed';
+type CommandCapabilities = {
+    blocking?: boolean;
+    pushOnly?: boolean;
+    movableKeys?: boolean;
+    scriptKeys?: boolean;
+    /**
+     * How the command behaves under cluster mode. `'forbidden'` is always
+     * rejected; `'singleDb'` is rejected only when it targets a non-zero
+     * database. Consumed by `ClusterPolicy` instead of matching command names.
+     */
+    clusterMode?: 'forbidden' | 'singleDb';
+    /**
+     * Marks the command as a transaction boundary. `'begin'` opens a transaction
+     * (MULTI); `'end'` closes one (EXEC/DISCARD). `ClusterPolicy` uses this to
+     * reset the per-session pinned slot instead of matching command names.
+     */
+    transactionBoundary?: 'begin' | 'end';
+};
+type CommandMonitorMetadata = {
+    skip?: boolean;
+    redactArgs?: (rawArgs: readonly Buffer[]) => readonly Buffer[];
+};
+type CommandKeySpec = {
+    flags: readonly string[];
+    beginSearchIndex: number;
+    lastKey: number;
+    keyStep: number;
+    limit?: number;
+    notes?: string;
+};
+type CommandDocumentation = {
+    summary: string;
+    since?: string;
+    group: string;
+    complexity?: string;
+    arguments?: readonly CommandDocumentationArgument[];
+};
+type CommandDocumentationArgument = {
+    name: string;
+    type: string;
+    keySpecIndex?: number;
+    token?: string;
+    flags?: readonly string[];
+};
+type CommandIntrospection = {
+    name?: string;
+    arity: number;
+    flags?: readonly string[];
+    firstKey?: number;
+    lastKey?: number;
+    keyStep?: number;
+    categories?: readonly string[];
+    tips?: readonly string[];
+    keySpecs?: readonly CommandKeySpec[];
+    subcommands?: readonly CommandIntrospection[];
+    docs?: CommandDocumentation;
+};
+type CommandExecutionResult = RedisResult | Promise<RedisResult> | ResponseStream;
+interface CommandDefinition<TArgs = unknown> {
+    readonly name: string;
+    readonly since?: VersionGate;
+    readonly schema: CommandSchema<TArgs>;
+    readonly flags: readonly CommandFlag[];
+    readonly capabilities?: CommandCapabilities;
+    readonly monitor?: CommandMonitorMetadata;
+    readonly introspection?: CommandIntrospection;
+    keys(args: TArgs): readonly Buffer[];
+    execute(args: TArgs, ctx: RedisExecutionContext): CommandExecutionResult;
+}
+type CommandPlan<TArgs = unknown> = {
+    definition: CommandDefinition<TArgs>;
+    args: TArgs;
+    keys: readonly Buffer[];
+    flags: readonly CommandFlag[];
+    rawCommand: Buffer;
+    rawArgs: readonly Buffer[];
+};
+declare function defineCommand<TArgs>(definition: CommandDefinition<TArgs>): CommandDefinition<TArgs>;
+
+declare class CommandRegistry {
+    private readonly commands;
+    register<TArgs>(definition: CommandDefinition<TArgs>, options?: {
+        override?: boolean;
+    }): void;
+    override<TArgs>(definition: CommandDefinition<TArgs>): void;
+    registerAll(definitions: readonly CommandDefinition<unknown>[], options?: {
+        override?: boolean;
+    }): void;
+    get(name: string): CommandDefinition<unknown> | undefined;
+    has(name: string): boolean;
+    getAll(): CommandDefinition<unknown>[];
+    getNames(): string[];
+}
+
+type PolicyResult = RedisResult | void;
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+interface ExecutionPolicy {
+    readonly name: string;
+    beforeExecute?(plan: CommandPlan, ctx: RedisExecutionContext): MaybePromise<PolicyResult>;
+    afterExecute?(plan: CommandPlan, ctx: RedisExecutionContext, result: RedisResult): MaybePromise<RedisResult>;
+    onStream?(plan: CommandPlan, ctx: RedisExecutionContext, stream: ResponseStream): MaybePromise<ResponseStream | void>;
+}
+
+/**
+ * The result of running a command: either a finished {@link RedisResult} or a
+ * long-lived {@link ResponseStream} (e.g. SUBSCRIBE / MONITOR) whose frames the
+ * transport drains over time.
+ */
+type ExecutorResult = RedisResult | ResponseStream;
+type RawExecutionResult = {
+    result: ExecutorResult;
+    plan?: CommandPlan;
+};
+type CommandExecutorOptions = {
+    registry: CommandRegistry;
+    policies?: readonly ExecutionPolicy[];
+    profile?: CompatibilityProfile;
+};
+/**
+ * Central command pipeline shared by every client session.
+ *
+ * Responsibilities:
+ *  1. Resolve a raw command name to a {@link CommandDefinition} (case-insensitive).
+ *  2. Parse raw argument buffers into typed args and extract routing keys,
+ *     producing a {@link CommandPlan}.
+ *  3. Run the configured {@link ExecutionPolicy} chain around the command's own
+ *     `execute`, giving policies (transaction, cluster, ...) a chance to
+ *     short-circuit, rewrite, or wrap the result.
+ *
+ * Two execution paths exist on purpose:
+ *  - {@link executePlan} / {@link executeRaw} — async, used for real network
+ *    clients; may return a {@link ResponseStream} and may await async commands.
+ *  - {@link executePlanSync} — synchronous mirror used by the Lua runtime, where
+ *    `redis.call` must complete in a single tick. Streams and promises are
+ *    rejected rather than awaited.
+ *
+ * The executor is stateless per-call: all mutable state lives on the
+ * {@link RedisExecutionContext} (and the session it carries).
+ */
+declare class CommandExecutor {
+    private readonly registry;
+    private readonly policies;
+    readonly profile: CompatibilityProfile;
+    constructor(options: CommandExecutorOptions);
+    getCommandDefinition(name: string): CommandDefinition<unknown> | undefined;
+    getCommandDefinitions(): readonly CommandDefinition<unknown>[];
+    /**
+     * Resolve a raw command + args into a {@link CommandPlan} without executing it.
+     * The command name is matched case-insensitively against the registry.
+     *
+     * @throws {UnknownRedisCommandError} if no command is registered under the name.
+     */
+    plan(rawCommand: Buffer | string, rawArgs: readonly Buffer[]): CommandPlan;
+    /**
+     * Plan and execute a raw command in one step — the normal entry point for a
+     * network client.
+     *
+     * Errors thrown during *planning* (unknown command, arity/parse failures) are
+     * caught here and converted into a RESP error reply. Such a failure also marks
+     * any open MULTI transaction dirty so a later EXEC is aborted, matching Redis:
+     * a command that cannot even be parsed must not silently vanish from the queue.
+     * Execution-time errors are handled inside {@link executePlan}.
+     */
+    executeRaw(rawCommand: Buffer | string, rawArgs: readonly Buffer[], ctx: RedisExecutionContext): Promise<ExecutorResult>;
+    executeRawWithPlan(rawCommand: Buffer | string, rawArgs: readonly Buffer[], ctx: RedisExecutionContext): Promise<RawExecutionResult>;
+    private static normalizeCommandName;
+    private rawCommandErrorResult;
+    /**
+     * Run a pre-built plan through the full async pipeline.
+     *
+     * Order of operations:
+     *  1. `beforeExecute` for each policy. The first policy that returns a result
+     *     short-circuits execution (e.g. the transaction policy queues the command
+     *     and returns "+QUEUED"; the cluster policy returns a MOVED/CROSSSLOT
+     *     error). A short-circuit error during MULTI also dirties the transaction.
+     *  2. The command's own `execute`.
+     *  3. If a {@link ResponseStream} is produced, run it through every policy's
+     *     `onStream` hook; otherwise await the value and run it through every
+     *     `afterExecute` hook (each may replace the result).
+     *
+     * Execution-time {@link RedisCommandError}s become RESP error replies (and
+     * dirty an open transaction when appropriate). Non-Redis errors propagate.
+     */
+    executePlan(plan: CommandPlan, ctx: RedisExecutionContext): Promise<ExecutorResult>;
+    private executePlanInternal;
+    /**
+     * Synchronous counterpart to {@link executePlan}, used by the Lua runtime for
+     * `redis.call` / `redis.pcall`. Lua expects each nested command to resolve
+     * immediately, so anything that would require awaiting — a command that
+     * returns a promise, a {@link ResponseStream}, or an async policy hook — is
+     * rejected with a {@link RedisCommandError} instead of being awaited. Async
+     * command definitions are rejected before invocation so they cannot leave
+     * orphaned work running after the script error (see
+     * {@link assertSyncCommandDefinition}, {@link assertSyncCommandResult}, and
+     * {@link assertSyncPolicyResult}).
+     *
+     * The policy chain and transaction-dirty handling otherwise mirror the async
+     * path exactly.
+     */
+    executePlanSync(plan: CommandPlan, ctx: RedisExecutionContext): RedisResult;
+    private executePlanSyncInternal;
+    /**
+     * Build a {@link CommandPlan} from a resolved definition: parse the raw buffers
+     * against the command's schema (may throw arity/type errors) and extract the
+     * routing keys used for cluster slot validation. Flags are copied onto the plan
+     * so policies can inspect them without re-resolving the definition.
+     */
+    private createPlan;
+}
+
+interface Logger {
+    info(msg: unknown, metadata?: Record<string, unknown>): void;
+    error(msg: unknown, metadata?: Record<string, unknown>): void;
+    debug(msg: unknown, metadata?: Record<string, unknown>): void;
+}
+
+type Resp2ServerOptions = {
+    server: RedisServerState;
+    executor: CommandExecutor;
+    logger?: Pick<Logger, 'error'>;
+    encoder?: RespEncodeOptions;
+    nodeRole?: RedisClusterNodeRole;
+};
+declare class Resp2Server {
+    readonly server: Server;
+    private readonly state;
+    private readonly executor;
+    private readonly logger?;
+    private readonly encoder?;
+    private readonly nodeRole?;
+    private readonly adapters;
+    constructor(options: Resp2ServerOptions);
+    listen(port?: number): Promise<void>;
+    close(): Promise<void>;
+    getAddress(): string;
+    getPort(): number;
+    private handleConnection;
+}
+
+type RedisClusterOptions = {
+    masters: number;
+    replicasPerMaster?: number;
+    basePort: number;
+    host?: string;
+    databasesPerNode?: number;
+    replicaUpdateDelayMs?: number;
+    compatibility?: CompatibilitySpec;
+    logger?: Pick<Logger, 'error'>;
+};
+declare function computeSlotRange(masterIndex: number, masters: number): [number, number];
+type ReplicationLink = {
+    close(): void;
+};
+
+type RedisClusterNodeHandle = {
+    id: string;
+    role: 'master' | 'replica';
+    host: string;
+    port: number;
+    server: RedisServerState;
+};
+/**
+ * A cluster of socket-backed nodes: {@link buildClusterNodes} assembles the
+ * TCP-free pipelines, this wraps each in a {@link Resp2Server} and owns their
+ * listen/close lifecycle. The socket layer of {@link buildClusterNodes} — kept
+ * out of `cluster.ts` so the node-assembly there stays free of `net`.
+ */
+declare class RedisCluster {
+    readonly topology: RedisClusterTopology;
+    readonly nodes: readonly RedisClusterNodeHandle[];
+    private readonly servers;
+    private readonly replicationLinks;
+    constructor(topology: RedisClusterTopology, nodes: readonly RedisClusterNodeHandle[], servers: readonly Resp2Server[], replicationLinks: readonly ReplicationLink[]);
+    listen(): Promise<void>;
+    close(): Promise<void>;
+    getAddresses(): string[];
+}
+/**
+ * Builds an **un-started** cluster — call {@link RedisCluster.listen} yourself.
+ *
+ * @deprecated Prefer {@link createRedisServer} with the `cluster` option, which
+ * builds *and* starts the cluster in one call (and is symmetric with
+ * `createRedisMock({ cluster })`). This low-level builder remains for callers
+ * that need to control when `listen()` runs.
+ */
+declare function createRedisCluster(options: RedisClusterOptions): RedisCluster;
+/**
+ * @deprecated Renamed to {@link createRedisCluster} for naming consistency with
+ * `createRedisServer` / `createRedisMock`. This alias will be removed in a
+ * future release.
+ */
+declare const buildRedisCluster: typeof createRedisCluster;
+
+declare class RedisCommandError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+declare class WrongNumberOfArgumentsError extends RedisCommandError {
+    constructor(commandName: string);
+}
+declare class RedisSyntaxError extends RedisCommandError {
+    constructor();
+}
+/** `AUTH <password>` (single-arg) when the server has no `requirepass` set. */
+declare class NoPasswordConfiguredError extends RedisCommandError {
+    constructor();
+}
+/** Wrong username/password pair on AUTH or HELLO AUTH. */
+declare class WrongPassError extends RedisCommandError {
+    constructor();
+}
+/** A command was issued before authenticating on a password-protected server. */
+declare class NoAuthError extends RedisCommandError {
+    constructor(message?: string);
+}
+/** `HELLO <version>` with a syntactically valid but unsupported protocol version. */
+declare class NoProtoError extends RedisCommandError {
+    constructor();
+}
+/** `HELLO <version>` where version is not a valid integer at all. */
+declare class HelloProtocolNotIntegerError extends RedisCommandError {
+    constructor();
+}
+declare class ExpectedIntegerError extends RedisCommandError {
+    constructor();
+}
+declare class IncrDecrOverflowError extends RedisCommandError {
+    constructor(message?: string);
+}
+declare class ExpectedFloatError extends RedisCommandError {
+    constructor();
+}
+declare class IncrByFloatNanOrInfinityError extends RedisCommandError {
+    constructor();
+}
+/** A non-ALPHA SORT met an element that does not parse as a double. */
+declare class SortScoreNotDoubleError extends RedisCommandError {
+    constructor();
+}
+declare class ResultingScoreNaNError extends RedisCommandError {
+    constructor();
+}
+declare class MinMaxNotFloatError extends RedisCommandError {
+    constructor();
+}
+declare class PositiveCountError extends RedisCommandError {
+    constructor();
+}
+declare class LposRankZeroError extends RedisCommandError {
+    constructor();
+}
+declare class LposCountNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class LposMaxlenNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class TimeoutNotFloatError extends RedisCommandError {
+    constructor();
+}
+declare class TimeoutNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class ZaddNxXxConflictError extends RedisCommandError {
+    constructor();
+}
+declare class ZaddGtLtNxConflictError extends RedisCommandError {
+    constructor();
+}
+declare class ExpireNxXxGtLtConflictError extends RedisCommandError {
+    constructor();
+}
+declare class ExpireGtLtConflictError extends RedisCommandError {
+    constructor();
+}
+declare class UnsupportedOptionError extends RedisCommandError {
+    constructor(option: string);
+}
+declare class ZaddIncrPairError extends RedisCommandError {
+    constructor();
+}
+declare class InvalidLongitudeLatitudeError extends RedisCommandError {
+    constructor(lon: number, lat: number);
+}
+declare class GeoUnsupportedUnitError extends RedisCommandError {
+    constructor();
+}
+declare class GeoMissingMemberError extends RedisCommandError {
+    constructor();
+}
+declare class GeoCountNotPositiveError extends RedisCommandError {
+    constructor();
+}
+declare class GeoAnyRequiresCountError extends RedisCommandError {
+    constructor();
+}
+declare class GeoRadiusNotNumericError extends RedisCommandError {
+    constructor();
+}
+declare class GeoRadiusNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class GeoWidthNotNumericError extends RedisCommandError {
+    constructor();
+}
+declare class GeoHeightNotNumericError extends RedisCommandError {
+    constructor();
+}
+declare class GeoBoxNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class GeoRadiusStoreWithOptionsError extends RedisCommandError {
+    constructor();
+}
+declare class GeoSearchStoreWithOptionsError extends RedisCommandError {
+    constructor();
+}
+declare class OffsetOutOfRangeError extends RedisCommandError {
+    constructor();
+}
+/** SETBIT/GETBIT/BITFIELD offset that is negative, non-integer, or >= 2^32. */
+declare class BitOffsetError extends RedisCommandError {
+    constructor();
+}
+/** SETBIT value that is not exactly 0 or 1. */
+declare class BitValueError extends RedisCommandError {
+    constructor();
+}
+/** BITPOS bit argument that is not 0 or 1. */
+declare class BitPosBitError extends RedisCommandError {
+    constructor();
+}
+/** BITOP NOT invoked with more than one source key. */
+declare class BitOpNotSingleKeyError extends RedisCommandError {
+    constructor();
+}
+/** BITFIELD type token that is malformed or u64 (only i64 is allowed at 64 bits). */
+declare class BitfieldTypeError extends RedisCommandError {
+    constructor();
+}
+/** BITFIELD OVERFLOW with a mode other than WRAP/SAT/FAIL. */
+declare class BitfieldOverflowTypeError extends RedisCommandError {
+    constructor();
+}
+/** A non-GET subcommand passed to BITFIELD_RO. */
+declare class BitfieldRoGetOnlyError extends RedisCommandError {
+    constructor();
+}
+declare class WrongTypeRedisError extends RedisCommandError {
+    constructor();
+}
+/** A string-type key whose contents are not a valid HyperLogLog encoding. */
+declare class InvalidHllError extends RedisCommandError {
+    constructor();
+}
+declare class InvalidExpireTimeError extends RedisCommandError {
+    constructor(commandName: string);
+}
+declare class RedisCrossSlotError extends RedisCommandError {
+    constructor();
+}
+declare class RedisMovedError extends RedisCommandError {
+    constructor(slot: number, host: string, port: number);
+}
+declare class RedisClusterDownError extends RedisCommandError {
+    constructor();
+}
+declare class UnknownScriptSubcommandError extends RedisCommandError {
+    constructor(subcommand: string | Buffer);
+}
+declare class UnknownClusterSubcommandError extends RedisCommandError {
+    constructor(subcommand: string | Buffer);
+}
+declare class ScriptFlushOptionError extends RedisCommandError {
+    constructor();
+}
+declare class ScriptDebugModeError extends RedisCommandError {
+    constructor();
+}
+declare class ScriptUnknownCommandError extends RedisCommandError {
+    constructor();
+}
+declare class ScriptNotAllowedCommandError extends RedisCommandError {
+    constructor();
+}
+declare class ScriptCallNoCommandError extends RedisCommandError {
+    constructor();
+}
+declare class WrongNumberOfKeysError extends RedisCommandError {
+    constructor();
+}
+declare class NumKeysGreaterThanZeroError extends RedisCommandError {
+    constructor();
+}
+/** ZUNION/ZINTER/ZDIFF family when numkeys <= 0. */
+declare class AtLeastOneInputKeyError extends RedisCommandError {
+    constructor(commandName: string);
+}
+declare class WeightNotFloatError extends RedisCommandError {
+    constructor();
+}
+declare class CountGreaterThanZeroError extends RedisCommandError {
+    constructor();
+}
+declare class LimitCantBeNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class StreamLimitRequiresApproxError extends RedisCommandError {
+    constructor();
+}
+declare class StreamLimitNegativeError extends RedisCommandError {
+    constructor();
+}
+declare class InvalidLexRangeError extends RedisCommandError {
+    constructor();
+}
+declare class ZrangeLimitWithoutByError extends RedisCommandError {
+    constructor();
+}
+declare class ZrangeWithScoresByLexError extends RedisCommandError {
+    constructor();
+}
+declare class NoScriptError extends RedisCommandError {
+    constructor();
+}
+declare class ExecWithoutMultiError extends RedisCommandError {
+    constructor();
+}
+declare class DiscardWithoutMultiError extends RedisCommandError {
+    constructor();
+}
+declare class WatchInsideMultiError extends RedisCommandError {
+    constructor();
+}
+declare class TransactionDiscardedError extends RedisCommandError {
+    constructor();
+}
+/** EXEC itself is malformed (e.g. wrong arity) — discards the transaction immediately. */
+declare class ExecCommandAbortError extends RedisCommandError {
+    constructor(reason: string);
+}
+declare class IndexOutOfRangeError extends RedisCommandError {
+    constructor();
+}
+declare class NoSuchKeyError extends RedisCommandError {
+    constructor();
+}
+/** `COPY src dst` (and `SELECT`) when source and destination resolve to the same object. */
+declare class SameObjectError extends RedisCommandError {
+    constructor();
+}
+/** A database index outside `0 .. databaseCount - 1` (e.g. `COPY ... DB 99`, `SELECT 99`). */
+declare class DbIndexOutOfRangeError extends RedisCommandError {
+    constructor();
+}
+declare class InvalidStreamIdError extends RedisCommandError {
+    constructor();
+}
+declare class StreamIdEqualOrSmallerError extends RedisCommandError {
+    constructor();
+}
+declare class StreamIdNotGreaterThanZeroError extends RedisCommandError {
+    constructor();
+}
+declare class StreamElementTooLargeError extends RedisCommandError {
+    constructor();
+}
+declare class StreamIdExhaustedError extends RedisCommandError {
+    constructor();
+}
+declare class HashValueNotIntegerError extends RedisCommandError {
+    constructor();
+}
+declare class HashValueNotFloatError extends RedisCommandError {
+    constructor();
+}
+declare class UnknownRedisCommandError extends RedisCommandError {
+    constructor(commandName: string | Buffer, args: readonly Buffer[]);
+}
+
+export { ZaddIncrPairError as $, ScriptUnknownCommandError as A, StreamElementTooLargeError as B, type CompatibilitySpec as C, DiscardWithoutMultiError as D, ExecWithoutMultiError as E, type FeatureId as F, StreamIdExhaustedError as G, HashValueNotFloatError as H, IndexOutOfRangeError as I, UnknownRedisCommandError as J, UnknownScriptSubcommandError as K, type Logger as L, MinMaxNotFloatError as M, NoAuthError as N, OffsetOutOfRangeError as O, PositiveCountError as P, WrongNumberOfArgumentsError as Q, RedisCluster as R, ScriptCallNoCommandError as S, TransactionDiscardedError as T, UnknownClusterSubcommandError as U, type VersionGate as V, WatchInsideMultiError as W, WrongNumberOfKeysError as X, WrongPassError as Y, WrongTypeRedisError as Z, ZaddGtLtNxConflictError as _, RedisServerState as a, LposMaxlenNegativeError as a$, ZaddNxXxConflictError as a0, buildRedisCluster as a1, computeSlotRange as a2, createRedisCluster as a3, gateSatisfied as a4, resolveCompatibilityProfile as a5, type ExecutionPolicy as a6, RedisClusterTopology as a7, type RedisClientSession as a8, type RedisClusterNodeRole as a9, type CommandSchema as aA, DbIndexOutOfRangeError as aB, ExecCommandAbortError as aC, type ExpirationState as aD, ExpireGtLtConflictError as aE, ExpireNxXxGtLtConflictError as aF, GeoAnyRequiresCountError as aG, GeoBoxNegativeError as aH, GeoCountNotPositiveError as aI, GeoHeightNotNumericError as aJ, GeoMissingMemberError as aK, GeoRadiusNegativeError as aL, GeoRadiusNotNumericError as aM, GeoRadiusStoreWithOptionsError as aN, GeoSearchStoreWithOptionsError as aO, GeoUnsupportedUnitError as aP, GeoWidthNotNumericError as aQ, HelloProtocolNotIntegerError as aR, IncrByFloatNanOrInfinityError as aS, IncrDecrOverflowError as aT, type InferSchema as aU, InvalidHllError as aV, InvalidLexRangeError as aW, InvalidLongitudeLatitudeError as aX, InvalidStreamIdError as aY, type KeyspaceEntry as aZ, LposCountNegativeError as a_, type ParkHandler as aa, type RedisTurnQueue as ab, type ClientSessionMode as ac, type RespVersion as ad, RedisDatabase as ae, type CommandPlan as af, RedisResult as ag, type Unsubscribe as ah, type ExecutorResult as ai, type RedisTurnHandle as aj, type RedisMonitorContext as ak, type RedisExecutionContext as al, type RespEncodeOptions as am, type CommandDefinition as an, CommandRegistry as ao, AtLeastOneInputKeyError as ap, BitOffsetError as aq, BitOpNotSingleKeyError as ar, BitPosBitError as as, BitValueError as at, BitfieldOverflowTypeError as au, BitfieldRoGetOnlyError as av, BitfieldTypeError as aw, type CommandCapabilities as ax, type CommandExecutionResult as ay, type CommandFlag as az, type RedisClusterNodeHandle as b, luaReplyToRedisValue as b$, LposRankZeroError as b0, type LuaReplyValue as b1, NoProtoError as b2, type ParkRequest as b3, type ParseContext as b4, type ParseNodeResult as b5, REDIS_CLUSTER_SLOT_COUNT as b6, type RedisClusterNode as b7, type RedisDataTypeName as b8, type RedisDataValue as b9, type SetOptions as bA, SortScoreNotDoubleError as bB, StreamIdEqualOrSmallerError as bC, StreamIdNotGreaterThanZeroError as bD, StreamLimitNegativeError as bE, StreamLimitRequiresApproxError as bF, TimeoutNegativeError as bG, TimeoutNotFloatError as bH, UnsupportedOptionError as bI, WeightNotFloatError as bJ, WrongRedisTypeError as bK, ZrangeLimitWithoutByError as bL, ZrangeWithScoresByLexError as bM, cloneRedisDataValue as bN, createDefaultParkHandler as bO, createHashData as bP, createListData as bQ, createNonBlockingParkHandler as bR, createNoopParkHandler as bS, createRedisLuaRuntime as bT, createSetData as bU, createSortedSetData as bV, createStringData as bW, defineCommand as bX, encodeRedisResult as bY, encodeRedisValue as bZ, isResponseStream as b_, RedisFunctionRegistry as ba, type RedisHashData as bb, type RedisHashField as bc, RedisKeyspace as bd, type RedisListData as be, RedisLuaRuntime as bf, type RedisMonitorCommandEvent as bg, type RedisMonitorCommandListener as bh, RedisMonitorFeed as bi, RedisMutationBus as bj, type RedisMutationEvent as bk, type RedisMutationListener as bl, RedisPubSubBroker as bm, type RedisResultOptions as bn, RedisScriptCache as bo, type RedisServerStateOptions as bp, type RedisSetData as bq, type RedisSortedSetData as br, type RedisSortedSetMember as bs, type RedisStreamData as bt, type RedisStringData as bu, type Resp2ServerOptions as bv, type ResponseStream as bw, SameObjectError as bx, ScriptNotAllowedCommandError as by, SerialTurnQueue as bz, Resp2Server as c, parseCommandArgs as c0, parseVersion as c1, setLuaWasmLoadOptions as c2, t as c3, CommandExecutor as d, RedisValue as e, type CompatibilityProfile as f, CountGreaterThanZeroError as g, ExpectedFloatError as h, ExpectedIntegerError as i, HashValueNotIntegerError as j, InvalidExpireTimeError as k, LimitCantBeNegativeError as l, NoPasswordConfiguredError as m, NoScriptError as n, NoSuchKeyError as o, NumKeysGreaterThanZeroError as p, RedisClusterDownError as q, type RedisClusterOptions as r, RedisCommandError as s, RedisCrossSlotError as t, type RedisFlavor as u, RedisMovedError as v, RedisSyntaxError as w, ResultingScoreNaNError as x, ScriptDebugModeError as y, ScriptFlushOptionError as z };