@liveblocks/server 1.0.1

package/dist/index.d.cts

@@ -0,0 +1,1414 @@
+import { DistributiveOmit, SetParentKeyOp, DeleteCrdtOp, ClientMsg as ClientMsg$1, JsonObject, Json, Brand, asPos, SerializedRootObject, SerializedChild, StorageNode, SerializedCrdt, Awaitable, PlainLsonObject, NodeMap, NodeStream, ClientWireOp, IgnoredOp, IUserInfo, ServerMsg as ServerMsg$1, BaseUserMeta } from '@liveblocks/core';
+export { BroadcastEventClientMsg, ClientMsg, ClientWireOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, DeleteCrdtOp, DeleteObjectKeyOp, FetchStorageClientMsg, FetchYDocClientMsg, HasOpId, IgnoredOp, Op, RoomStateServerMsg, ServerMsg, ServerWireOp, SetParentKeyOp, UpdateObjectOp, UpdatePresenceClientMsg, UpdateStorageClientMsg, UpdateYDocClientMsg } from '@liveblocks/core';
+import * as decoders from 'decoders';
+import { Decoder } from 'decoders';
+import { Mutex } from 'async-mutex';
+import * as Y from 'yjs';
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+declare enum ProtocolVersion {
+    /**
+     * V7 changes the URL params used to authorize the user.
+     *
+     * In V6 and lower, the ?token= URL param is used, which will only ever
+     * contain a `pub-legacy` or `sec-legacy` token.
+     *
+     * URL PARAM CHANGES:
+     * Starting with V7, the ?token= is no longer a legal URL param. Instead,
+     * either of the following params is used:
+     *
+     * - ?tok=... for ID tokens
+     * - ?tok=... for Access tokens
+     * - ?tok=... for Secret Legacy tokens
+     * - ?pubkey=... for public keys (no token, public key can be directly used here)
+     *
+     * Note that `pub-legacy` tokens are no longer accepted in V7, and are
+     * replaced by the direct use of the public key.
+     *
+     * BEHAVIORAL CHANGES:
+     * Starting with V7, the RoomState server message that gets sent when
+     * a client initially connects will now include new fields:
+     *
+     * - `actor`
+     * - `scopes`
+     *
+     * Since v1.2.0 (Jul 31, 2023)
+     */
+    V7 = 7,
+    /**
+     * V8 changes storage response format and allows streaming.
+     *
+     * MESSAGE FORMAT CHANGES:
+     * - V8: sends 1+ STORAGE_CHUNK messages, followed by 1 final
+     *       STORAGE_STREAM_END message (with compact nodes)
+     * - V7: sends 1 STORAGE_STATE_V7 message (with full nodes)
+     *
+     * STREAMING BEHAVIOR in V8:
+     * - For SQLite-backed rooms: nodes are split into multiple STORAGE_CHUNK
+     *   messages, followed by STORAGE_STREAM_END
+     * - For KV-backed rooms: all nodes are sent in a single STORAGE_CHUNK
+     *   message that will contain all nodes, followed by STORAGE_STREAM_END
+     *
+     * Since 3.14.0
+     */
+    V8 = 8
+}
+declare const protocolVersionDecoder: decoders.Decoder<ProtocolVersion>;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+type FixOp = DistributiveOmit<SetParentKeyOp | DeleteCrdtOp, "opId">;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare const clientMsgDecoder: Decoder<ClientMsg$1<JsonObject, Json>>;
+declare const transientClientMsgDecoder: Decoder<ClientMsg$1<JsonObject, Json>>;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Drop-in replacement for the `json` decoder from the decoders standard
+ * library, but implemented as a no-op. This is, of course, only safe to use in
+ * contexts where you know that the input already is valid JSON.
+ *
+ * You know this for sure, for example, if you're decoding the result of
+ * a `JSON.parse()` call.
+ *
+ * Done for performance reasons!
+ */
+declare const jsonYolo: Decoder<Json>;
+/**
+ * Drop-in replacement for the `jsonObject` decoder from the decoders standard
+ * library, but implemented as just a check for plain old JavaScript object.
+ * This is, of course, only safe to use in contexts where you know that the
+ * input already is valid JSON.
+ *
+ * You know this for sure, for example, if you're decoding the result of
+ * a `JSON.parse()` call.
+ *
+ * Done for performance reasons!
+ */
+declare const jsonObjectYolo: Decoder<JsonObject>;
+
+/**
+ * A guid, a unique identifier for a Yjs sub document.
+ */
+type Guid = Brand<string, "Guid">;
+declare const guidDecoder: decoders.Decoder<Guid>;
+declare const ROOT_YDOC_ID = "root";
+type YDocId = typeof ROOT_YDOC_ID | Guid;
+/**
+ * Any string that is a valid base64 encoded YJS update.
+ */
+type YUpdate = Brand<string, "YUpdate">;
+/**
+ * Any string that is a valid base64 encoded YJS state vector.
+ */
+type YVector = Brand<string, "YVector">;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Generic, minimal, WebSocket interface that must be available or implemented
+ * on the server.
+ */
+interface IServerWebSocket {
+    /**
+     * Send should be synchronous and never throw. It should return:
+     * - Return  -1 if sending was attempted, but there was back pressure
+     *                 (i.e. the receiving end wasn't ready to accept more
+     *                  bytes right now)
+     * - Return   0 if sending failed (due to a connection issue)
+     * - Return >=1 if sent successfully (number of bytes sent)
+     */
+    send(msg: string | ArrayBuffer): number;
+    close(code: number, reason?: string): void;
+    /**
+     * Optional. Returns the last auto-response timestamp. Used only on
+     * Cloudflare, where pings and pongs are typically handled by an
+     * auto-response.
+     */
+    getLastPongTimestamp?(): Date | null;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARNING = 2,
+    ERROR = 3
+}
+/**
+ * Inherit from this abstract log target to implement your own custom
+ * LogTarget.
+ */
+declare abstract class LogTarget {
+    #private;
+    readonly level: LogLevel;
+    constructor(level?: LogLevel | keyof typeof LogLevelNames);
+    /** Helper for formatting a log level */
+    protected formatLevel(level: LogLevel): string;
+    /** Helper for formatting an Arg */
+    protected formatArg(arg: string | Error): string;
+    /**
+     * Helper for formatting a Context. Override this in a subclass to change the
+     * formatting.
+     */
+    protected formatContextImpl(context: JsonObject): string;
+    /**
+     * Helper for formatting a Context. Will only compute the string once for
+     * every Context instance, and keep its computed string value cached for
+     * performance.
+     */
+    protected formatContext(context: JsonObject): string;
+    /**
+     * Implement this in a concrete subclass. The goal is to do whatever to log
+     * the given log level, context, and log arg. You'll typically want to
+     * utilize the pre-defined helper methods .formatContext() and .formatArg()
+     * to implement this.
+     */
+    abstract log(level: LogLevel, context: JsonObject, arg: string | Error): void;
+}
+declare class ConsoleTarget extends LogTarget {
+    log(level: LogLevel, context: JsonObject, arg: string | Error): void;
+}
+declare const LogLevelNames: {
+    readonly debug: LogLevel.DEBUG;
+    readonly info: LogLevel.INFO;
+    readonly warning: LogLevel.WARNING;
+    readonly error: LogLevel.ERROR;
+};
+type LogFn = (arg: string | Error) => void;
+/**
+ * Structured logger with configurable log targets.
+ */
+declare class Logger {
+    readonly debug: LogFn;
+    readonly info: LogFn;
+    readonly warn: LogFn;
+    readonly error: LogFn;
+    readonly o: {
+        readonly debug?: LogFn;
+        readonly info?: LogFn;
+        readonly warn?: LogFn;
+        readonly error?: LogFn;
+    };
+    private readonly _context;
+    private readonly _targets;
+    constructor(target?: LogTarget | readonly LogTarget[], context?: JsonObject);
+    /**
+     * Creates a new Logger instance with the given extra context applied. All
+     * log calls made from that new Logger will carry all current _and_ the extra
+     * context, with the extra context taking precedence. Assign an explicit
+     * `undefined` value to a key to "remove" it from the context.
+     */
+    withContext(extra: JsonObject): Logger;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+type Pos = ReturnType<typeof asPos>;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * An isolated, read-only copy of the storage document at a point in time.
+ *
+ * Two iteration styles are supported:
+ *
+ * 1. Tree traversal (top-down):
+ *    Call get_root() to get the root, then use iter_children() + get_node()
+ *    to walk the tree depth-first. This preserves parent-child ordering and is
+ *    used by the JSON/LSON serializers.
+ *
+ * 2. Flat iteration:
+ *    Call iter_all() to get all nodes as unordered [id, crdt] pairs. Useful
+ *    when the tree structure doesn't matter (e.g. streaming raw NDJSON).
+ *
+ * Always call destroy() when done (use a try/finally wrapper).
+ */
+interface IReadableSnapshot {
+    /** Get the root node. */
+    get_root(): SerializedRootObject;
+    /** Get a child node by id. */
+    get_node(id: string): SerializedChild;
+    /**
+     * Iterate all children of a node. Each child is yielded as [parentKey,
+     * childId]. Children will be yielded in their parent_key order.
+     */
+    iter_children(nodeId: string): Iterable<[parentKey: string, childId: string]>;
+    /**
+     * Get all nodes as [id, crdt] pairs (flat, unordered).
+     */
+    iter_all(): Iterable<StorageNode>;
+    /**
+     * Release all resources held by the snapshot. Must be called when the
+     * snapshot is no longer needed (e.g. after the stream completes or is
+     * aborted).
+     */
+    destroy(): void;
+}
+/**
+ * CRDT node storage with synchronous reads and async persistence.
+ *
+ * INVARIANTS:
+ * - A virtual root node `{type: OBJECT, data: {}}` always exists.
+ * - All non-root nodes have parentId and parentKey forming a tree.
+ * - Reads reflect writes immediately, before the returned Promise resolves.
+ */
+interface IStorageDriverNodeAPI {
+    /**
+     * Return the node with the given id, or undefined if no such node exists.
+     * Must always return a valid root node for id="root", even if empty.
+     */
+    get_node(id: string): SerializedCrdt | undefined;
+    /**
+     * Yield all nodes as [id, node] pairs. Must always include the root node.
+     */
+    iter_nodes(): Iterable<StorageNode>;
+    /**
+     * Return true iff a node with the given id exists. Must return true for "root".
+     */
+    has_node(id: string): boolean;
+    /**
+     * Return the id of the child node at (parentId, parentKey), or undefined if
+     * none. Only checks child nodes registered via set_child, NOT static data
+     * keys on OBJECT nodes.
+     */
+    get_child_at(parentId: string, parentKey: string): string | undefined;
+    /**
+     * Return true iff a child node exists at (parentId, parentKey). Static data
+     * keys on OBJECT nodes do not count—return false for those.
+     */
+    has_child_at(parentId: string, parentKey: string): boolean;
+    /**
+     * Return the position of the closest sibling "to the right" of `pos` under
+     * parentId, or undefined if no such sibling exists. The given `pos` may, but
+     * does not have to exist already. Positions compare lexicographically.
+     */
+    get_next_sibling(parentId: string, pos: Pos): Pos | undefined;
+    /**
+     * Insert a child node with the given id.
+     *
+     * If allowOverwrite=false (default): throw if a node with this id exists.
+     * If allowOverwrite=true: replace any existing node at this id, deleting its
+     * entire subtree if it has children.
+     */
+    set_child(id: string, node: SerializedChild, allowOverwrite?: boolean): Awaitable<void>;
+    /**
+     * Change a node's parentKey, effectively repositioning the node within its
+     * parent. The new position must be free.
+     * Throw if another node already occupies (parentId, newPos).
+     */
+    move_sibling(id: string, newPos: Pos): Awaitable<void>;
+    /**
+     * Delete a node and its entire subtree recursively.
+     * Ignore if id="root" (root is immortal).
+     */
+    delete_node(id: string): Awaitable<void>;
+    /**
+     * Delete a key from node `id`. Handle two cases:
+     *
+     * 1. If id is an OBJECT with `key` in its data: remove that data field.
+     * 2. If a child exists at (id, key): delete that child and all its
+     *    descendants recursively.
+     *
+     * No-op if neither applies or if the node doesn't exist.
+     */
+    delete_child_key(id: string, key: string): Awaitable<void>;
+    /**
+     * Replace the data object of an OBJECT node.
+     *
+     * If allowOverwrite=false (default): throw if any key in `data` conflicts
+     * with an existing child's parentKey.
+     * If allowOverwrite=true: first delete any conflicting children (and their
+     * entire subtrees), then set the data.
+     */
+    set_object_data(id: string, data: JsonObject, allowOverwrite?: boolean): Awaitable<void>;
+    /**
+     * Return a readable snapshot of the storage tree.
+     *
+     * @param lowMemory When true, the call site hints that the snapshot should
+     * be optimized for lower memory consumption, even if that means slower
+     * access.
+     */
+    get_snapshot(lowMemory?: boolean): IReadableSnapshot;
+}
+/**
+ * Persistent storage backend for Liveblocks room data: CRDT nodes, metadata,
+ * actor IDs, and Yjs updates. All methods may be async.
+ */
+interface IStorageDriver {
+    /**
+     * Load all nodes from storage, validate/repair corruptions (orphans, cycles,
+     * conflicting siblings), and return an IStorageDriverNodeAPI for operations.
+     *
+     * After DANGEROUSLY_reset_nodes(), any previously-loaded instance is
+     * invalid—must call this again to get a fresh one.
+     */
+    load_nodes_api(logger: Logger): Awaitable<IStorageDriverNodeAPI>;
+    /**
+     * Delete all CRDT nodes and replace them with the given document.
+     * Does NOT affect metadata, actor IDs, or Yjs updates.
+     * Invalidates any previously-loaded IStorageDriverNodeAPI.
+     *
+     * Pass `{ liveblocksType: "LiveObject", data: {} }` to reset to an empty root.
+     */
+    DANGEROUSLY_reset_nodes(doc: PlainLsonObject): Awaitable<void>;
+    /**
+     * Return the value for `key`, or undefined if not set.
+     */
+    get_meta(key: string): Awaitable<Json | undefined>;
+    /**
+     * Store `value` under `key`. Overwrite any existing value.
+     */
+    put_meta(key: string, value: Json): Awaitable<void>;
+    /**
+     * Delete the value under `key`. No-op if not set.
+     */
+    delete_meta(key: string): Awaitable<void>;
+    /**
+     * Return a unique actor ID. Each call must return a distinct integer ≥ 0.
+     * Concurrent calls must never return duplicates.
+     */
+    next_actor(): Awaitable<number>;
+    /**
+     * If defined, called once before each storage mutation batch. Can be used by
+     * the driver to more efficiently implement snapshot isolation.
+     */
+    bump_storage_version?(): void;
+    /**
+     * Return all Yjs updates for docId as [key, data] pairs. Return empty if none.
+     */
+    iter_y_updates(docId: YDocId): Awaitable<Iterable<[string, Uint8Array]>>;
+    /**
+     * Store a Yjs update under (docId, key). Overwrite if key exists.
+     */
+    write_y_updates(docId: YDocId, key: string, data: Uint8Array): Awaitable<void>;
+    /**
+     * Delete the specified keys for docId.
+     */
+    delete_y_updates(docId: YDocId, keys: string[]): Awaitable<void>;
+    /**
+     * Delete ALL Yjs updates across ALL documents.
+     * @private Test-only: never use in production.
+     */
+    DANGEROUSLY_wipe_all_y_updates(): Awaitable<void>;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Serialize a storage snapshot to a simple JSON representation, returning a
+ * full in-memory JsonObject. Faster than snapshotToLossyJson_lazy for
+ * small/medium documents because the result can be passed straight to
+ * JSON.stringify(). This format is lossy — the original storage structure
+ * cannot be reconstructed from it, so it's output-only.
+ */
+declare function snapshotToLossyJson_eager(snapshot: IReadableSnapshot): JsonObject;
+type StringGen$1 = Generator<string, void, never>;
+/**
+ * Serialize a storage snapshot to a simple JSON representation. This format is
+ * easy to consume but lossy — the original storage structure cannot be
+ * reconstructed from it, so it's an output-only format. Slower than
+ * snapshotToLossyJson_eager but can stream documents that don't fit entirely
+ * in memory.
+ *
+ * This generator yields text chunks that together, when concatenated, form the
+ * output JSON document.
+ */
+declare function snapshotToLossyJson_lazy(snapshot: IReadableSnapshot): StringGen$1;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Yield all nodes from a snapshot as [id, crdt] tuples.
+ * Destroys the snapshot when done (or aborted).
+ */
+declare function snapshotToNodeStream(snapshot: IReadableSnapshot): Generator<StorageNode, void, never>;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Transform a "Plain LSON" document to a lazy NodeStream. Used to initialize
+ * the storage with a predefined state.
+ * Always emits parent nodes before their children.
+ */
+declare function plainLsonToNodeStream(root: PlainLsonObject): Generator<StorageNode, void, undefined>;
+/**
+ * Serialize a storage snapshot to "Plain LSON" format, returning a full
+ * in-memory PlainLsonObject. Faster than snapshotToPlainLson_lazy for
+ * small/medium documents because the result can be passed straight to
+ * JSON.stringify().
+ */
+declare function snapshotToPlainLson_eager(snapshot: IReadableSnapshot): PlainLsonObject;
+type StringGen = Generator<string, void, never>;
+/**
+ * Serialize a storage snapshot to "Plain LSON" format. Yields string chunks
+ * that, when concatenated, form a valid JSON string representing the storage
+ * document. Slower than snapshotToPlainLson_eager but can stream documents
+ * that don't fit entirely in memory.
+ */
+declare function snapshotToPlainLson_lazy(snapshot: IReadableSnapshot): StringGen;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Create a basic in-memory snapshot from a set of storage nodes.
+ *
+ * Takes a copy of the provided nodes, so the snapshot is isolated from
+ * subsequent mutations to the source.
+ */
+declare function makeInMemorySnapshot(values: NodeMap | NodeStream): IReadableSnapshot;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+interface MetadataDB {
+    get(key: string): Promise<Json | undefined>;
+    get<T>(decoder: Decoder<T>, key: string): Promise<T | undefined>;
+    put(key: string, value: Json): Awaitable<void>;
+    delete(key: string): Awaitable<void>;
+}
+/**
+ * Returns a thin wrapper around an IStorageDriver to provide MetadataDB
+ * functionality, including type-safe reads.
+ */
+declare function makeMetadataDB(driver: IStorageDriver): MetadataDB;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+type ApplyOpResult = OpAccepted | OpIgnored;
+type OpAccepted = {
+    action: "accepted";
+    op: ClientWireOp;
+    fix?: FixOp;
+};
+type OpIgnored = {
+    action: "ignored";
+    ignoredOpId?: string;
+};
+declare class Storage {
+    private readonly coreDriver;
+    private _loadedDriver;
+    constructor(coreDriver: IStorageDriver);
+    get loadedDriver(): IStorageDriverNodeAPI;
+    raw_iter_nodes(): Awaitable<Iterable<[string, SerializedCrdt]>>;
+    /**
+     * Load the room data from object storage into memory. Persisted room
+     * data consists of the main node map, which represents the Liveblocks
+     * Storage tree, and special keys where we store usage metrics, or room
+     * metadata.
+     */
+    load(logger: Logger): Promise<void>;
+    unload(): void;
+    /**
+     * Applies a batch of Ops.
+     */
+    applyOps(ops: ClientWireOp[]): Promise<ApplyOpResult[]>;
+    /**
+     * Applies a single Op.
+     */
+    private applyOp;
+    private applyCreateOp;
+    private createChildAsListItem;
+    private applyDeleteObjectKeyOp;
+    private applyUpdateObjectOp;
+    private applyDeleteCrdtOp;
+    private applySetParentKeyOp;
+    /**
+     * Inserts a new node in the storage tree, under a list parent. If an
+     * existing sibling node already exist under this key, however, it will look
+     * for another free position under that parent and insert it under
+     * a different parent key that is guaranteed to be available.
+     *
+     * Returns the key that was used for the insertion.
+     */
+    private insertIntoList;
+    /**
+     * Tries to move a node to the given position under the same parent. If
+     * a conflicting sibling node already exist at this position, it will use
+     * another free position instead, to avoid the conflict.
+     *
+     * Returns the position (parentKey) that the node was eventually placed at.
+     * If the node could be inserted without conflict, it will return the same
+     * parentKey position.
+     *
+     * Will return `undefined` if this action could not be interpreted. Will be
+     * a no-op for non-list items.
+     */
+    private moveToPosInList;
+    /**
+     * Checks whether the given parentKey is a "free position" under the
+     * parentId, i.e. there are no siblings that have the same key. If a sibling
+     * exists under that key, it tries to generate new positions until it finds
+     * a free slot, and returns that. The returned value is therefore always safe
+     * to use as parentKey.
+     */
+    private findFreeListPosition;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare class YjsStorage {
+    private readonly driver;
+    private readonly doc;
+    private readonly lastUpdatesById;
+    private readonly lastSnapshotById;
+    private readonly keysById;
+    private readonly initPromisesById;
+    constructor(driver: IStorageDriver);
+    getYDoc(docId: YDocId): Promise<Y.Doc>;
+    /**
+     * If passed a state vector, an update with diff will be returned, if not the entire doc is returned.
+     *
+     * @param stateVector a base64 encoded target state vector created by running Y.encodeStateVector(Doc) on the client
+     * @returns a base64 encoded array of YJS updates
+     */
+    getYDocUpdate(logger: Logger, stateVector?: string, guid?: Guid, isV2?: boolean): Promise<string | null>;
+    getYDocUpdateBinary(logger: Logger, stateVector?: string, guid?: Guid, isV2?: boolean): Promise<Uint8Array | null>;
+    getYStateVector(guid?: Guid): Promise<string | null>;
+    getSnapshotHash(options: {
+        guid?: Guid;
+        isV2?: boolean;
+    }): Promise<string | null>;
+    /**
+     * @param update base64 encoded uint8array
+     * @returns
+     */
+    addYDocUpdate(logger: Logger, update: string | Uint8Array, guid?: Guid, isV2?: boolean): Promise<{
+        isUpdated: boolean;
+        snapshotHash: string;
+    }>;
+    loadDocByIdIfNotAlreadyLoaded(docId: YDocId): Promise<Y.Doc>;
+    load(_logger: Logger): Promise<void>;
+    /**
+     * Unloads the Yjs documents from memory.
+     */
+    unload(): void;
+    private _getOrPutLastSnapshot;
+    private _putLastSnapshot;
+    /**
+     * Given a record of updates, merge them and compress if savings are significant
+     */
+    private _loadAndCompressYJSUpdates;
+    private _loadYDocFromDurableStorage;
+    private findYSubdocByGuid;
+    private calculateSnapshotHash;
+    private getYSubdoc;
+    private handleYDocUpdate;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+type LoadingState = "initial" | "loading" | "loaded";
+type ActorID = Brand<number, "ActorID">;
+/**
+ * Session keys are also known as the "nonce" in the protocol. It's a random,
+ * unique, but PRIVATE, identifier for the session, and it's important that
+ * this ID is never shared to anyone except the connected client, which
+ * receives it as part of its ROOM_STATE message.
+ */
+type SessionKey = Brand<string, "SessionKey">;
+type PreSerializedServerMsg = Brand<string, "PreSerializedServerMsg">;
+type ClientMsg = ClientMsg$1<JsonObject, Json>;
+type ServerMsg = ServerMsg$1<JsonObject, BaseUserMeta, Json>;
+declare function serialize(msgs: ServerMsg | readonly ServerMsg[]): PreSerializedServerMsg;
+declare function ackIgnoredOp(opId: string): IgnoredOp;
+/**
+ * A known or anonymous user.
+ *
+ * BY DEFINITION:
+ * A User with an assigned `id` property is a non-anonymous user.
+ * A User with an assigned `anonymousId` property is an anonymous user.
+ * A User with neither of those properties is also an anonymous user.
+ *
+ * WHAT'S THE DIFFERENCE?
+ * When creating a non-anonymous user, other users in the room will be able to
+ * observe the assigned `id` property in Presence (e.g. via the `other.user.id`
+ * in the Liveblocks client).
+ *
+ * When creating an anonymous user, you can _optionally_ provide an anonymous
+ * ID to (re)use. While not authorized, this still allows you to correlate
+ * unique users.
+ */
+type IUserData = AuthorizedUser | AnonymousUser;
+type AuthorizedUser = {
+    readonly id: string;
+    readonly anonymousId?: never;
+    readonly info?: IUserInfo;
+};
+type AnonymousUser = {
+    readonly anonymousId: string;
+    readonly id?: never;
+    readonly info?: IUserInfo;
+};
+/**
+ * Each BrowserSession is an abstraction around a socket instance, and maintains
+ * metadata about the connection.
+ */
+declare class BrowserSession<SM, CM extends JsonObject> {
+    #private;
+    readonly version: ProtocolVersion;
+    readonly actor: ActorID;
+    readonly createdAt: Date;
+    readonly user: IUserData;
+    readonly scopes: string[];
+    readonly meta: SM;
+    readonly publicMeta?: CM;
+    get lastActiveAt(): Date;
+    get hasNotifiedClientStorageUpdateError(): boolean;
+    markActive(now?: Date): void;
+    setHasNotifiedClientStorageUpdateError(): void;
+    sendPong(): number;
+    send(serverMsg: ServerMsg | ServerMsg[] | PreSerializedServerMsg): number;
+}
+declare class BackendSession extends BrowserSession<never, never> {
+}
+type Ticket<SM, CM extends JsonObject> = {
+    readonly sessionKey: SessionKey;
+    readonly version: ProtocolVersion;
+    readonly actor: ActorID;
+    readonly meta?: SM;
+    readonly publicMeta?: CM;
+    readonly user: IUserData;
+    readonly scopes: string[];
+};
+type CreateTicketOptions<SM, CM extends JsonObject> = {
+    /** The Liveblocks protocol version this client will speak */
+    version?: ProtocolVersion;
+    meta?: SM;
+    publicMeta?: CM;
+    /** A user-provided ID to externally recognize the user by */
+    id?: string;
+    /**
+     * A user-provided anonymous ID to use. When `id` is provided, this field is
+     * ignored. When both fields are missing, a new anonymous ID will be
+     * generated.
+     */
+    anonymousId?: string;
+    /** Static user metadata to assign this session, will get broadcasted to other clients */
+    info?: IUserInfo;
+    /** Permissions to assign this session */
+    scopes?: string[];
+    /** An explicit actor ID to use. Supported for legacy use cases only. It's best to not set this and let it get assigned dynamically, as it's important for this identifier to be unique. */
+    actor?: ActorID;
+};
+type RoomOptions<SM, CM extends JsonObject, C> = {
+    /**
+     * Bring your own persistence backend
+     */
+    storage?: IStorageDriver;
+    logger?: Logger;
+    /**
+     * Whether to allow streaming storage responses. Only safe with drivers
+     * that can guarantee that no Ops from other clients can get interleaved
+     * between the chunk generation until the last chunk has been sent.
+     * Defaults to true, but is notably NOT safe to use from DOS-KV backends.
+     */
+    allowStreaming?: boolean;
+    hooks?: {
+        /** Customize which incoming messages from a client are allowed or disallowed. */
+        isClientMsgAllowed?: (msg: ClientMsg, session: BrowserSession<SM, CM>) => {
+            allowed: true;
+        } | {
+            allowed: false;
+            reason: string;
+        };
+        /** Called whenever the server acknowledged a ping with a pong */
+        onDidPong?: (ctx?: C) => void | Promise<void>;
+        /** Called before the room is attempted to be loaded */
+        onRoomWillLoad?: (ctx?: C) => void | Promise<void>;
+        /** Called right after the room's contents are loaded, but before any session has been started */
+        onRoomDidLoad?: (ctx?: C) => void | Promise<void>;
+        /** Called right before the room is attempted to be unloaded. Synchronous. May throw to abort the unloading. */
+        onRoomWillUnload?: (ctx?: C) => void;
+        /** Called right after the room has been unloaded from memory. Synchronous. */
+        onRoomDidUnload?: (ctx?: C) => void;
+        /** Called when a new user entered the room. */
+        onSessionDidStart?: (session: BrowserSession<SM, CM>, ctx?: C) => void | Promise<void>;
+        /** Called when a user left the room. */
+        onSessionDidEnd?: (session: BrowserSession<SM, CM>, ctx?: C) => void | Promise<void>;
+        /**
+         * Called when Liveblocks Storage for the room was updated.
+         *
+         * IMPORTANT! If you implement these as async functions, it's important to
+         * note that these run outside of the storage mutex that guarantees
+         * a consistent view of storage.
+         * Therefore, only ever use this hook to implement a side effect (like
+         * trigger a notification), don't read storage in this hook directly.
+         */
+        postClientMsgStorageDidUpdate?: (ctx?: C) => void | Promise<void>;
+        /**
+         * Called when Yjs Storage for the room was updated.
+         *
+         * IMPORTANT! If you implement these as async functions, it's important to
+         * note that these run outside of the storage mutex that guarantees
+         * a consistent view of storage.
+         * Therefore, only ever use this hook to implement a side effect (like
+         * trigger a notification), don't read storage in this hook directly.
+         */
+        postClientMsgYdocDidUpdate?: (ctx?: C, sess?: BrowserSession<SM, CM>) => void | Promise<void>;
+    };
+    /** Enable debug logging */
+    enableDebugLogging?: boolean;
+};
+/**
+ * A Liveblocks Room server.
+ */
+declare class Room<RM, SM, CM extends JsonObject, C = undefined> {
+    #private;
+    meta: RM;
+    readonly driver: IStorageDriver;
+    logger: Logger;
+    private _loadData$;
+    private _data;
+    private _qsize;
+    private readonly sessions;
+    private readonly hooks;
+    constructor(meta: RM, options?: RoomOptions<SM, CM, C>);
+    get loadingState(): LoadingState;
+    get numSessions(): number;
+    get storage(): Storage;
+    get yjsStorage(): YjsStorage;
+    get mutex(): Mutex;
+    private get data();
+    /**
+     * Initializes the Room, so it's ready to start accepting connections. Safe
+     * to call multiple times. After awaiting `room.load()` the Room is ready to
+     * be used.
+     */
+    load(ctx?: C): Promise<void>;
+    /**
+     * Releases the currently-loaded storage tree from worker memory, freeing it
+     * up to be garbage collected. The next time a user will join the room, the
+     * room will be reloaded from storage.
+     */
+    unload(ctx?: C): void;
+    /**
+     * Issues a Ticket with a new/unique actor ID
+     *
+     * IMPORTANT! As the caller of this function, you are responsible for
+     * ensuring you trust the values passed in here. Never pass unauthorized
+     * values in here.
+     *
+     * The returned Ticket can be turned into a active Session once the socket
+     * connection is established. If the socket is never established, this
+     * unused Ticket will simply get garbage collected.
+     */
+    createTicket(options?: CreateTicketOptions<SM, CM>): Promise<Ticket<SM, CM>>;
+    createBackendSession_experimental(): Promise<[
+        session: BackendSession,
+        outgoingMessages: PreSerializedServerMsg[]
+    ]>;
+    /**
+     * Restores the given sessions as the Room server's session list. Can only be
+     * called as long as there are no existing sessions.
+     *
+     * The key difference with the .startBrowserSession() API is that restoreSessions is
+     * used in cases where a session was hibernated and needs to be restored,
+     * without _conceptually_ starting a new session.
+     *
+     * Because there are no side effects to restoreSession, it's synchronous.
+     */
+    restoreSessions(sessions: {
+        ticket: Ticket<SM, CM>;
+        socket: IServerWebSocket;
+        lastActivity: Date;
+    }[]): void;
+    /**
+     * Registers a new BrowserSession into the Room server's session list, along with
+     * the socket connection to use for that BrowserSession, now that it is known.
+     *
+     * This kicks off a few side effects:
+     * - Sends a ROOM_STATE message to the socket.
+     * - Broadcasts a USER_JOINED message to all other sessions in the room.
+     */
+    startBrowserSession(ticket: Ticket<SM, CM>, socket: IServerWebSocket, ctx?: C, defer?: (promise: Promise<void>) => void): void;
+    /**
+     * Unregisters the BrowserSession for the given actor. Call this when the socket has
+     * been closed from the client's end.
+     *
+     * This kicks off a few side effects:
+     * - Broadcasts a USER_LEFT message to all other sessions in the room.
+     */
+    endBrowserSession(key: SessionKey, code: number, reason: string, ctx?: C, defer?: (promise: Promise<void>) => void): void;
+    /**
+     * Force-closes all sessions matching the given predicate.
+     */
+    endSessionBy(predicate: (session: BrowserSession<SM, CM>) => boolean, code: number, reason: string, ctx?: C, defer?: (promise: Promise<void>) => void): number;
+    /**
+     * Handles a raw incoming socket message, which can be a ping, or an
+     * JSON-encoded message batch.
+     */
+    handleData(key: SessionKey, data: unknown, ctx?: C, defer?: (promise: Promise<void>) => void): Promise<void>;
+    /**
+     * Processes an incoming batch of 1 or more ClientMsgs on behalf of
+     * a (regular user/browser) session.
+     *
+     * IMPORTANT: Only use this API on "trusted" data!
+     * To handle untrusted input data, use `.handleData()` instead.
+     *
+     * Before calling this API, make sure:
+     * 1. The call site is entitled to call this message on behalf of this session; and
+     * 2. The ClientMsg payload has been validated to be correct.
+     */
+    processClientMsg(key: SessionKey, messages: ClientMsg[], ctx?: C): Promise<void>;
+    /**
+     * Processes an incoming batch of 1 or more ClientMsgs on behalf of
+     * a BACKEND session.
+     *
+     * Difference 1: HTTP RESPONSE instead of WEB SOCKET RESPONSE
+     * ----------------------------------------------------------
+     * For "normal" sessions that have a socket attached, any "responses" (i.e.
+     * server messages like acks or fixops) will be sent back through that
+     * existing socket connection.
+     *
+     * The key difference when using this method is that there is no such socket,
+     * so any "response" ServerMsgs will get sent back as an HTTP response.
+     *
+     * Difference 2: No auth check
+     * ---------------------------
+     * Another key difference is that when processing a backend session, no
+     * "isClientMsgAllowed()" check is performed, because those checks assume
+     * a session.
+     */
+    processClientMsgFromBackendSession(session: BackendSession, messages: ClientMsg[], ctx?: C): Promise<void>;
+    getSession(sessionKey: SessionKey): BrowserSession<SM, CM> | undefined;
+    listSessions(): BrowserSession<SM, CM>[];
+    /**
+     * Will send the given ServerMsg to all Sessions, except the Session
+     * where the message originates from.
+     */
+    sendToOthers(sender: SessionKey, serverMsg: ServerMsg | readonly ServerMsg[], ctx?: C, defer?: (promise: Promise<void>) => void): void;
+    /**
+     * Will broadcast the given ServerMsg to all Sessions in the Room.
+     */
+    sendToAll(serverMsg: ServerMsg | readonly ServerMsg[], ctx?: C, defer?: (promise: Promise<void>) => void): void;
+    private _loadStorage;
+    private _loadYjsStorage;
+    private _load;
+    /**
+     * Returns a new, unique, actor ID.
+     */
+    private getNextActor;
+    /**
+     * Iterates over all *other* Sessions and their session keys.
+     */
+    private otherSessionEntries;
+    /**
+     * Iterates over all *other* Sessions.
+     */
+    private otherSessions;
+    private _processClientMsg_withExclusiveAccess;
+    private _processClientMsgFromBackendSession_withExclusiveAccess;
+    private handleOne;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Concatenates multiple Uint8Arrays into a single Uint8Array.
+ */
+declare function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Given a promise or promise factory, returns a 2-tuple of success or failure.
+ * This pattern avoids having to build deeply nested try / catch clauses, where
+ * success variables need to be defined as a `let` outside of the `try` block.
+ *
+ * Turns:
+ *
+ *   let result;
+ *   try {
+ *     result = await doSomething();
+ *   } catch (error) {
+ *     // do something with error
+ *   }
+ *
+ *   doAnotherThing(result);
+ *
+ * Into:
+ *
+ *   const [result, error] = await tryCatch(doSomething());
+ *   if (error) {
+ *     // do something with error
+ *   }
+ *   doAnotherThing(result);
+ *
+ */
+declare function tryCatch<T, E = Error>(promise: Promise<T> | (() => Promise<T>) | (() => T)): Promise<[T, undefined] | [undefined, E]>;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Like ES6 map, but takes a default (factory) function which will be used
+ * to create entries for missing keys on the fly.
+ *
+ * Useful for code like:
+ *
+ *   const map = new DefaultMap(() => []);
+ *   map.getOrCreate('foo').push('hello');
+ *   map.getOrCreate('foo').push('world');
+ *   map.getOrCreate('foo')
+ *   // ['hello', 'world']
+ *
+ */
+declare class DefaultMap<K, V> extends Map<K, V> {
+    #private;
+    /**
+     * If the default function is not provided to the constructor, it has to be
+     * provided in each .getOrCreate() call individually.
+     */
+    constructor(defaultFn?: (key: K) => V, entries?: readonly (readonly [K, V])[] | null);
+    /**
+     * Gets the value at the given key, or creates it.
+     *
+     * Difference from normal Map: if the key does not exist, it will be created
+     * on the fly using the factory function, and that value will get returned
+     * instead of `undefined`.
+     */
+    getOrCreate(key: K, defaultFn?: (key: K) => V): V;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Like an ES6 Map, but two levels deep. Useful for building reverse lookup
+ * tables. Will automatically delete second-level maps when they are empty.
+ */
+declare class NestedMap<K1, K2, V> {
+    #private;
+    constructor();
+    get size(): number;
+    count(key1: K1): number;
+    keys(): IterableIterator<[K1, K2]>;
+    has(key1: K1, key2: K2): boolean;
+    get(key1: K1, key2: K2): V | undefined;
+    set(key1: K1, key2: K2, value: V): this;
+    delete(key1: K1, key2: K2): void;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[K1, K2, V]>;
+    entriesAt(key1: K1): IterableIterator<[K2, V]>;
+    filterAt(key1: K1, keys: Iterable<K2>): Iterable<[K2, V]>;
+    keysAt(key1: K1): IterableIterator<K2>;
+    valuesAt(key1: K1): IterableIterator<V>;
+    deleteAll(key1: K1): void;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Wraps single-quotes around any string value. Useful for displaying field
+ * names or other identifiers in error messages or logs.
+ *
+ * Examples:
+ *   quote("hi")   // "'hi'"
+ *   quote("i'm")  // "'i'm'"
+ *
+ * Note: no "escaping" happens here to the string value. This is because this
+ * is intended to be used for human consumption, not machine consumption.
+ */
+declare function quote(value: string | undefined): string;
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * Like ES6 map, but also provides a unique reverse lookup index for values
+ * stored in the map.
+ *
+ * Useful for code like:
+ *
+ *   // Store a list of persons by their IDs, but each person's email must also
+ *   // be unique
+ *   const map = new UniqueMap((person) => person.email);
+ *   map.set(1, { name: 'John Doe', email: 'john@example.org' });
+ *   map.set(2, { name: 'John Foo', email: 'john@example.org' });  // Will error!
+ *   map.delete(1);
+ *   map.set(3, { name: 'Johnny', email: 'john@example.org' });  // Now it's allowed
+ *
+ *   map.getReverseKey('john@example.org')  // 3
+ *   map.getReverse('john@example.org')  // { name: 'Johnny', email: 'john@example.org' }
+ *
+ */
+declare class UniqueMap<K, V, UK> extends Map<K, V> {
+    #private;
+    constructor(keyFn: (value: V) => UK);
+    lookupPrimaryKey(uniqKey: UK): K | undefined;
+    lookup(uniqKey: UK): V | undefined;
+    set(key: K, value: V): this;
+    delete(primaryKey: K): boolean;
+}
+
+/**
+ * Copyright (c) Liveblocks Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/**
+ * Implements the most basic in-memory store. Used if no explicit store is
+ * provided.
+ */
+declare class InMemoryDriver implements IStorageDriver {
+    private _nextActor;
+    private _nodes;
+    private _metadb;
+    private _ydb;
+    constructor(options?: {
+        initialActor?: number;
+        initialNodes?: Iterable<[string, SerializedCrdt]>;
+    });
+    raw_iter_nodes(): IterableIterator<[string, SerializedCrdt]>;
+    /** Deletes all nodes and replaces them with the given document. */
+    DANGEROUSLY_reset_nodes(doc: PlainLsonObject): void;
+    get_meta(key: string): Promise<Json | undefined>;
+    put_meta(key: string, value: Json): Promise<void>;
+    delete_meta(key: string): Promise<void>;
+    next_actor(): number;
+    iter_y_updates(docId: YDocId): Promise<IterableIterator<[string, Uint8Array]>>;
+    write_y_updates(docId: YDocId, key: string, data: Uint8Array): Promise<void>;
+    delete_y_updates(docId: YDocId, keys: string[]): Promise<void>;
+    /** @private Only use this in unit tests, never in production. */
+    DANGEROUSLY_wipe_all_y_updates(): Promise<void>;
+    load_nodes_api(): IStorageDriverNodeAPI;
+}
+
+export { type ActorID, BackendSession, BrowserSession, ConsoleTarget, type CreateTicketOptions, DefaultMap, type FixOp, type Guid, type IReadableSnapshot, type IServerWebSocket, type IStorageDriver, type IStorageDriverNodeAPI, type IUserData, InMemoryDriver, type LoadingState, LogLevel, LogTarget, Logger, type MetadataDB, NestedMap, type Pos, type PreSerializedServerMsg, ProtocolVersion, ROOT_YDOC_ID, Room, type SessionKey, type Ticket, UniqueMap, type YDocId, type YUpdate, type YVector, ackIgnoredOp, clientMsgDecoder, concatUint8Arrays, guidDecoder, jsonObjectYolo, jsonYolo, makeInMemorySnapshot, makeMetadataDB, plainLsonToNodeStream, protocolVersionDecoder, quote, serialize as serializeServerMsg, snapshotToLossyJson_eager, snapshotToLossyJson_lazy, snapshotToNodeStream, snapshotToPlainLson_eager, snapshotToPlainLson_lazy, Storage as test_only__Storage, YjsStorage as test_only__YjsStorage, transientClientMsgDecoder, tryCatch };