@liveblocks/core 3.20.0-rc1 → 3.21.0-exp1

package/dist/index.d.cts

@@ -64,6 +64,83 @@ type DistributiveRelax<T, Ks extends string | number | symbol> = T extends any ?
     [K in Exclude<Ks, keyof T>]?: never;
 }> : never;
 
+declare const Permission: {
+    /**
+     * Default permission for a room.
+     */
+    readonly Read: "*:read";
+    readonly Write: "*:write";
+    /**
+     * Legacy aliases for default room permissions.
+     */
+    readonly RoomWrite: "room:write";
+    readonly RoomRead: "room:read";
+    /**
+     * Storage
+     */
+    readonly StorageRead: "storage:read";
+    readonly StorageWrite: "storage:write";
+    readonly StorageNone: "storage:none";
+    /**
+     * Comments
+     */
+    readonly CommentsWrite: "comments:write";
+    readonly CommentsRead: "comments:read";
+    readonly CommentsNone: "comments:none";
+    /**
+     * Feeds
+     */
+    readonly FeedsRead: "feeds:read";
+    readonly FeedsWrite: "feeds:write";
+    readonly FeedsNone: "feeds:none";
+    /**
+     * Legacy
+     */
+    readonly LegacyRoomPresenceWrite: "room:presence:write";
+};
+type Permission = (typeof Permission)[keyof typeof Permission];
+declare const ACCESS_LEVELS: readonly ["none", "read", "write"];
+type AccessLevel = (typeof ACCESS_LEVELS)[number];
+type RequiredAccessLevel = "read" | "write";
+type PermissionMatrix = {
+    room: AccessLevel;
+    storage: AccessLevel;
+    comments: AccessLevel;
+    feeds: AccessLevel;
+    personal: AccessLevel;
+};
+type PermissionResources = keyof PermissionMatrix;
+type RoomPermissions = Permission[];
+type RoomAccesses = Record<string, RoomPermissions>;
+type UpdateRoomAccesses = Record<string, RoomPermissions | null>;
+declare function permissionMatrixFromScopes(scopes: RoomPermissions): PermissionMatrix;
+declare function hasPermissionAccess(matrix: Partial<PermissionMatrix>, resource: PermissionResources, requiredAccess: RequiredAccessLevel): boolean;
+declare function normalizeRoomPermissions(permissions: string[] | readonly string[]): RoomPermissions;
+declare function normalizeRoomAccesses(accesses: RoomAccesses | undefined): RoomAccesses | undefined;
+declare function normalizeUpdateRoomAccesses(accesses: UpdateRoomAccesses | undefined): UpdateRoomAccesses | undefined;
+/**
+ * Merges permission scopes from multiple sources, by priority: explicit user
+ * accesses override group accesses, which override the room defaults. Groups
+ * all share the same priority, so they are first merged together by taking
+ * the highest access level per feature (and base).
+ */
+declare function mergeRoomPermissionScopes({ defaultAccesses, groupsAccesses, userAccesses, }: {
+    defaultAccesses: RoomPermissions;
+    groupsAccesses: RoomPermissions[];
+    userAccesses: RoomPermissions;
+}): RoomPermissions;
+/**
+ * Validates a set of permissions:
+ * - every scope must be a known permission scope,
+ * - exactly one base permission is required (*:read, *:write, or the legacy
+ *   aliases room:read, room:write),
+ * - at most one scope per feature (storage, comments, feeds, ...),
+ * - room:presence:write is accepted as an extra legacy scope.
+ *
+ * Returns `true` when the set is valid, or an error message otherwise.
+ */
+declare function validatePermissionsSet(scopes: readonly string[]): true | string;
+
 type CustomAuthenticationResult = Relax<{
     token: string;
 } | {
@@ -132,15 +209,6 @@ type BaseUserMeta = {
     info?: IUserInfo;
 };
 
-declare enum Permission {
-    Read = "room:read",
-    Write = "room:write",
-    PresenceWrite = "room:presence:write",
-    CommentsWrite = "comments:write",
-    CommentsRead = "comments:read",
-    FeedsWrite = "feeds:write"
-}
-
 type RenameDataField<T, TFieldName extends string> = T extends any ? {
     [K in keyof T as K extends "data" ? TFieldName : K]: T[K];
 } : never;
@@ -242,90 +310,6 @@ type BatchStore<O, I> = {
     invalidate: (inputs?: I[]) => void;
 };
 
-declare const kTrigger: unique symbol;
-/**
- * Runs a callback function that is allowed to change multiple signals. At the
- * end of the batch, all changed signals will be notified (at most once).
- *
- * Nesting batches is supported.
- */
-declare function batch(callback: Callback<void>): void;
-type SignalType<S extends ISignal<any>> = S extends ISignal<infer T> ? T : never;
-interface ISignal<T> {
-    get(): T;
-    subscribe(callback: Callback<void>): UnsubscribeCallback;
-    addSink(sink: DerivedSignal<unknown>): void;
-    removeSink(sink: DerivedSignal<unknown>): void;
-}
-/**
- * Base functionality every Signal implementation needs.
- */
-declare abstract class AbstractSignal<T> implements ISignal<T>, Observable<void> {
-    #private;
-    constructor(equals?: (a: T, b: T) => boolean);
-    dispose(): void;
-    abstract get(): T;
-    get hasWatchers(): boolean;
-    [kTrigger](): void;
-    subscribe(callback: Callback<void>): UnsubscribeCallback;
-    subscribeOnce(callback: Callback<void>): UnsubscribeCallback;
-    waitUntil(): never;
-    markSinksDirty(): void;
-    addSink(sink: DerivedSignal<unknown>): void;
-    removeSink(sink: DerivedSignal<unknown>): void;
-    asReadonly(): ISignal<T>;
-}
-declare class Signal<T> extends AbstractSignal<T> {
-    #private;
-    constructor(value: T, equals?: (a: T, b: T) => boolean);
-    dispose(): void;
-    get(): T;
-    set(newValue: T | ((oldValue: T) => T)): void;
-}
-declare class DerivedSignal<T> extends AbstractSignal<T> {
-    #private;
-    static from<Ts extends unknown[], V>(...args: [...signals: {
-        [K in keyof Ts]: ISignal<Ts[K]>;
-    }, transform: (...values: Ts) => V]): DerivedSignal<V>;
-    static from<Ts extends unknown[], V>(...args: [...signals: {
-        [K in keyof Ts]: ISignal<Ts[K]>;
-    }, transform: (...values: Ts) => V, equals: (a: V, b: V) => boolean]): DerivedSignal<V>;
-    private constructor();
-    dispose(): void;
-    get isDirty(): boolean;
-    markDirty(): void;
-    get(): T;
-    /**
-     * Called by the Signal system if one or more of the dependent signals have
-     * changed. In the case of a DerivedSignal, we'll only want to re-evaluate
-     * the actual value if it's being watched, or any of their sinks are being
-     * watched actively.
-     */
-    [kTrigger](): void;
-}
-/**
- * A MutableSignal is a bit like Signal, except its state is managed by
- * a single value whose reference does not change but is mutated.
- *
- * Similar to how useSyncExternalState() works in React, there is a way to read
- * the current state at any point in time synchronously, and a way to update
- * its reference.
- */
-declare class MutableSignal<T extends object> extends AbstractSignal<T> {
-    #private;
-    constructor(initialState: T);
-    dispose(): void;
-    get(): T;
-    /**
-     * Invokes a callback function that is allowed to mutate the given state
-     * value. Do not change the value outside of the callback.
-     *
-     * If the callback explicitly returns `false`, it's assumed that the state
-     * was not changed.
-     */
-    mutate(callback?: (state: T) => void | boolean): void;
-}
-
 type ContextualPromptResponse = Relax<{
     type: "insert";
     text: string;
@@ -427,6 +411,8 @@ declare const OpCode: Readonly<{
     DELETE_OBJECT_KEY: 6;
     CREATE_MAP: 7;
     CREATE_REGISTER: 8;
+    CREATE_TEXT: 9;
+    UPDATE_TEXT: 10;
 }>;
 declare namespace OpCode {
     type INIT = typeof OpCode.INIT;
@@ -438,13 +424,48 @@ declare namespace OpCode {
     type DELETE_OBJECT_KEY = typeof OpCode.DELETE_OBJECT_KEY;
     type CREATE_MAP = typeof OpCode.CREATE_MAP;
     type CREATE_REGISTER = typeof OpCode.CREATE_REGISTER;
+    type CREATE_TEXT = typeof OpCode.CREATE_TEXT;
+    type UPDATE_TEXT = typeof OpCode.UPDATE_TEXT;
 }
+type TextAttributes = JsonObject;
+/**
+ * A single segment in a {@link LiveTextData} document.
+ *
+ * @example
+ * ["Hello world"]
+ * ["Hello ", { bold: true }]
+ */
+type LiveTextSegment = readonly [text: string] | readonly [text: string, attributes: TextAttributes];
+/**
+ * Serialized form of a {@link LiveText} document: an ordered list of text
+ * segments with optional inline attributes.
+ *
+ * @example
+ * [["Hello world"]]
+ * [["Hello ", { bold: true }], ["world"]]
+ */
+type LiveTextData = readonly LiveTextSegment[];
+type TextOperation = {
+    type: "insert";
+    index: number;
+    text: string;
+    attributes?: TextAttributes;
+} | {
+    type: "delete";
+    index: number;
+    length: number;
+} | {
+    type: "format";
+    index: number;
+    length: number;
+    attributes: JsonObject;
+};
 /**
  * These operations are the payload for {@link UpdateStorageServerMsg} messages
  * only.
  */
-type Op = CreateOp | UpdateObjectOp | DeleteCrdtOp | SetParentKeyOp | DeleteObjectKeyOp;
-type CreateOp = CreateObjectOp | CreateRegisterOp | CreateMapOp | CreateListOp;
+type Op = CreateOp | UpdateObjectOp | UpdateTextOp | DeleteCrdtOp | SetParentKeyOp | DeleteObjectKeyOp;
+type CreateOp = CreateObjectOp | CreateRegisterOp | CreateMapOp | CreateListOp | CreateTextOp;
 type UpdateObjectOp = {
     readonly opId?: string;
     readonly id: string;
@@ -489,6 +510,26 @@ type CreateRegisterOp = {
     readonly intent?: "set" | "push";
     readonly deletedId?: string;
 };
+type CreateTextOp = {
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.CREATE_TEXT;
+    readonly parentId: string;
+    readonly parentKey: string;
+    readonly data: LiveTextData;
+    readonly version: number;
+    readonly intent?: "set" | "push";
+    readonly deletedId?: string;
+};
+type UpdateTextOp = {
+    readonly opId?: string;
+    readonly id: string;
+    readonly type: OpCode.UPDATE_TEXT;
+    readonly baseVersion: number;
+    readonly version?: number;
+    readonly ops: TextOperation[];
+    readonly metadata?: JsonObject;
+};
 type DeleteCrdtOp = {
     readonly opId?: string;
     readonly id: string;
@@ -617,15 +658,17 @@ declare const CrdtType: Readonly<{
     LIST: 1;
     MAP: 2;
     REGISTER: 3;
+    TEXT: 4;
 }>;
 declare namespace CrdtType {
     type OBJECT = typeof CrdtType.OBJECT;
     type LIST = typeof CrdtType.LIST;
     type MAP = typeof CrdtType.MAP;
     type REGISTER = typeof CrdtType.REGISTER;
+    type TEXT = typeof CrdtType.TEXT;
 }
 type SerializedCrdt = SerializedRootObject | SerializedChild;
-type SerializedChild = SerializedObject | SerializedList | SerializedMap | SerializedRegister;
+type SerializedChild = SerializedObject | SerializedList | SerializedMap | SerializedRegister | SerializedText;
 type SerializedRootObject = {
     readonly type: CrdtType.OBJECT;
     readonly data: JsonObject;
@@ -654,13 +697,21 @@ type SerializedRegister = {
     readonly parentKey: string;
     readonly data: Json;
 };
+type SerializedText = {
+    readonly type: CrdtType.TEXT;
+    readonly parentId: string;
+    readonly parentKey: string;
+    readonly data: LiveTextData;
+    readonly version: number;
+};
 type StorageNode = RootStorageNode | ChildStorageNode;
-type ChildStorageNode = ObjectStorageNode | ListStorageNode | MapStorageNode | RegisterStorageNode;
+type ChildStorageNode = ObjectStorageNode | ListStorageNode | MapStorageNode | RegisterStorageNode | TextStorageNode;
 type RootStorageNode = [id: "root", value: SerializedRootObject];
 type ObjectStorageNode = [id: string, value: SerializedObject];
 type ListStorageNode = [id: string, value: SerializedList];
 type MapStorageNode = [id: string, value: SerializedMap];
 type RegisterStorageNode = [id: string, value: SerializedRegister];
+type TextStorageNode = [id: string, value: SerializedText];
 type NodeMap = Map<string, SerializedCrdt>;
 type NodeStream = Iterable<StorageNode>;
 declare function isRootStorageNode(node: StorageNode): node is RootStorageNode;
@@ -668,8 +719,9 @@ declare function isObjectStorageNode(node: StorageNode): node is RootStorageNode
 declare function isListStorageNode(node: StorageNode): node is ListStorageNode;
 declare function isMapStorageNode(node: StorageNode): node is MapStorageNode;
 declare function isRegisterStorageNode(node: StorageNode): node is RegisterStorageNode;
+declare function isTextStorageNode(node: StorageNode): node is TextStorageNode;
 type CompactNode = CompactRootNode | CompactChildNode;
-type CompactChildNode = CompactObjectNode | CompactListNode | CompactMapNode | CompactRegisterNode;
+type CompactChildNode = CompactObjectNode | CompactListNode | CompactMapNode | CompactRegisterNode | CompactTextNode;
 type CompactRootNode = readonly [id: "root", data: JsonObject];
 type CompactObjectNode = readonly [
     id: string,
@@ -697,6 +749,14 @@ type CompactRegisterNode = readonly [
     parentKey: string,
     data: Json
 ];
+type CompactTextNode = readonly [
+    id: string,
+    type: CrdtType.TEXT,
+    parentId: string,
+    parentKey: string,
+    data: LiveTextData,
+    version: number
+];
 declare function compactNodesToNodeStream(compactNodes: CompactNode[]): NodeStream;
 declare function nodeStreamToCompactNodes(nodes: NodeStream): Iterable<CompactNode>;
 
@@ -745,6 +805,14 @@ type SyncMode = boolean | "atomic" | SyncConfig;
 type SyncConfig = {
     [key: string]: SyncMode | undefined;
 };
+/**
+ * Deeply converts all nested lists to LiveLists, and all nested objects to
+ * LiveObjects.
+ *
+ * As such, the returned result will not contain any Json arrays or Json
+ * objects anymore.
+ */
+declare function deepLiveify(value: Json, config?: SyncMode): Lson;
 
 /**
  * Optional keys of O whose non-undefined type is plain Json (not a
@@ -854,16 +922,244 @@ declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
     clone(): LiveObject<O>;
 }
 
+/**
+ * Use this symbol to brand an object property as internal.
+ *
+ * @example
+ * Object.defineProperty(
+ *   {
+ *     public,
+ *     [kInternal]: {
+ *       private
+ *     },
+ *   },
+ *   kInternal,
+ *   {
+ *     enumerable: false,
+ *   }
+ * );
+ */
+declare const kInternal: unique symbol;
+declare const kStorageUpdateSource: unique symbol;
+
+/**
+ * The position of the ops being transformed relative to the ops they are
+ * transformed over, in the final (server-serialized) timeline:
+ *
+ * - "after": the transformed ops will be ordered after the `over` ops. Used
+ *   when rebasing a not-yet-accepted op over already-accepted ops. On
+ *   same-index insert ties, the transformed op shifts right (the earlier op
+ *   stays left), and conflicting format attributes are kept (they will
+ *   overwrite, since the op applies later).
+ * - "before": the transformed ops were ordered before the `over` ops. Used
+ *   when applying an accepted remote op on top of locally-pending ops. On
+ *   same-index insert ties, the transformed op stays left, and conflicting
+ *   format attributes are dropped on overlapping ranges (the later `over` op
+ *   wins).
+ */
+type TransformOrder = "before" | "after";
+/**
+ * Transform `ops` over `over` (see {@link transformTextOperationsX}),
+ * returning only the transformed `ops`.
+ */
+declare function transformTextOperations(ops: readonly TextOperation[], over: readonly TextOperation[], order: TransformOrder): TextOperation[];
+declare function applyLiveTextOperations(data: LiveTextData, ops: readonly TextOperation[]): LiveTextData;
+
+type LiveTextAttributes = TextAttributes;
+type LiveTextAttributesPatch = JsonObject;
+
+type LiveTextChange = {
+    /** Text was inserted at {@link LiveTextChange.index}. */
+    readonly type: "insert";
+    readonly index: number;
+    readonly text: string;
+    readonly attributes?: TextAttributes;
+} | {
+    /** Text was deleted starting at {@link LiveTextChange.index}. */
+    readonly type: "delete";
+    readonly index: number;
+    readonly length: number;
+    readonly deletedText: string;
+} | {
+    /** Inline attributes were updated on a range of text. */
+    readonly type: "format";
+    readonly index: number;
+    readonly length: number;
+    readonly attributes: LiveTextAttributesPatch;
+};
+/** Notification payload when a {@link LiveText} node changes. */
+type LiveTextUpdates = {
+    type: "LiveText";
+    node: LiveText;
+    version: number;
+    updates: LiveTextChange[];
+};
+/**
+ * @private
+ *
+ * Private methods on a LiveText node. As a user of Liveblocks, NEVER USE ANY
+ * OF THESE DIRECTLY, because bad things will probably happen if you do.
+ */
+type PrivateLiveTextApi = {
+    /**
+     * Encode a local-document index into server-confirmed coordinates suitable
+     * for broadcasting to peers via presence or any other side channel. Pair
+     * the result with {@link LiveText.version} at the same instant when
+     * sending.
+     */
+    encodeIndex(localIndex: number): number;
+    /**
+     * Decode an `(index, fromVersion)` pair from a peer into an offset in this
+     * LiveText's current local document.
+     */
+    decodeIndex(index: number, fromVersion: number): number | null;
+};
+
+/**
+ * LiveText is a collaborative rich-text primitive built on server-ordered
+ * operational transformation.
+ *
+ * Use it to store plain text with optional inline formatting attributes in
+ * Liveblocks Storage. Each document is a flat sequence of text segments; it
+ * cannot contain child Storage structures.
+ *
+ * Outbound model (one-in-flight): at most one UpdateTextOp per node is
+ * awaiting server acknowledgement at any time. Local edits made while an op
+ * is in flight are queued and sent (composed into a single op) once the ack
+ * arrives. This guarantees every wire op is expressed against server-state
+ * coordinates, so the server can transform it over exactly the (foreign)
+ * ops the client hadn't seen — never over the client's own pending ops.
+ *
+ * Inbound model: accepted remote ops are transformed over the local pending
+ * ops before being applied ("before" order: the accepted op wins ties), and
+ * the pending ops are re-expressed over the remote op in turn ("after"
+ * order), keeping them in server coordinates at all times.
+ *
+ * @example
+ * const text = new LiveText("Hello");
+ * text.insert(5, " world");
+ * text.format(0, 5, { bold: true });
+ *
+ * // [["Hello", { bold: true }], [" world"]]
+ * text.toJSON();
+ *
+ * @example
+ * // Use in Storage
+ * declare global {
+ *   interface Liveblocks {
+ *     Storage: { document: LiveText };
+ *   }
+ * }
+ *
+ * const { root } = await room.getStorage();
+ * root.get("document").replace(0, root.get("document").length, "Updated");
+ */
+declare class LiveText extends AbstractCrdt {
+    #private;
+    /**
+     * @private
+     *
+     * Private methods and variables used in the core internals, but as a user
+     * of Liveblocks, NEVER USE ANY OF THESE DIRECTLY, because bad things
+     * will probably happen if you do.
+     */
+    readonly [kInternal]: PrivateLiveTextApi;
+    /**
+     * Creates a new LiveText document.
+     *
+     * @param textOrData Initial plain text, or an array of `[text]` /
+     *   `[text, attributes]` segments. Defaults to an empty document.
+     *
+     * @example
+     * new LiveText();
+     * new LiveText("Hello world");
+     * new LiveText([["Hello ", { bold: true }], ["world"]]);
+     */
+    constructor(textOrData?: string | LiveTextData, version?: number);
+    get version(): number;
+    get length(): number;
+    /**
+     * Inserts text at the given index.
+     *
+     * @param index Character index at which to insert. Values outside the
+     *   document range are clipped.
+     * @param text Text to insert.
+     * @param attributes Optional inline attributes for the inserted text.
+     *
+     * @example
+     * const text = new LiveText("Hello");
+     * text.insert(5, " world");
+     * text.insert(0, "Say: ", { italic: true });
+     */
+    insert(index: number, text: string, attributes?: TextAttributes): void;
+    /**
+     * Deletes `length` characters starting at `index`.
+     *
+     * @example
+     * const text = new LiveText("Hello world");
+     * text.delete(5, 6); // "Hello"
+     */
+    delete(index: number, length: number): void;
+    /**
+     * Replaces a range of text with new text.
+     *
+     * @example
+     * const text = new LiveText("Hello world");
+     * text.replace(0, 5, "Hi"); // "Hi world"
+     */
+    replace(index: number, length: number, text: string, attributes?: TextAttributes): void;
+    /**
+     * Applies or removes inline attributes on a range of text.
+     *
+     * Set an attribute to `null` to remove it from the range.
+     *
+     * @example
+     * const text = new LiveText("Hello world");
+     * text.format(0, 5, { bold: true });
+     * text.format(0, 5, { bold: null });
+     */
+    format(index: number, length: number, attributes: LiveTextAttributesPatch): void;
+    /** Returns the plain text content without attributes. Equivalent to joining the text from each segment in {@link LiveText.toJSON}. */
+    toString(): string;
+    /**
+     * Returns a JSON-compatible snapshot of the document as a {@link LiveTextData}
+     * array.
+     *
+     * @example
+     * new LiveText([["Hello ", { bold: true }], ["world"]]).toJSON();
+     * // [["Hello ", { bold: true }], ["world"]]
+     */
+    toJSON(): LiveTextData;
+    clone(): LiveText;
+}
+
 type StorageCallback = (updates: StorageUpdate[]) => void;
 type LiveMapUpdate = LiveMapUpdates<string, Lson>;
 type LiveObjectUpdate = LiveObjectUpdates<LsonObject>;
 type LiveListUpdate = LiveListUpdates<Lson>;
+type LiveTextUpdate = LiveTextUpdates;
+type StorageUpdateSource = {
+    origin: "remote";
+} | {
+    origin: "local";
+    via: "mutation";
+} | {
+    origin: "local";
+    via: "history";
+    action: "undo" | "redo";
+};
 /**
  * The payload of notifications sent (in-client) when LiveStructures change.
  * Messages of this kind are not originating from the network, but are 100%
  * in-client.
+ *
+ * Updates delivered through `room.subscribe` may carry
+ * `[kStorageUpdateSource]` to distinguish where a mutation came from.
+ * Undo/redo replays use `via: "history"` with `action: "undo" | "redo"`.
  */
-type StorageUpdate = LiveMapUpdate | LiveObjectUpdate | LiveListUpdate;
+type StorageUpdate = (LiveMapUpdate | LiveObjectUpdate | LiveListUpdate | LiveTextUpdate) & {
+    [kStorageUpdateSource]?: StorageUpdateSource;
+};
 
 /**
  * Read-only query surface over {@link UnacknowledgedOps}, handed to CRDTs so
@@ -878,8 +1174,27 @@ interface ReadonlyUnacknowledgedOps {
      * the given ones (i.e. targeting one exact position).
      */
     getByParentIdAndKey(parentId: string, parentKey: string): Iterable<ClientWireCreateOp>;
+    /**
+     * Whether the given pending op may already have been processed by the
+     * server. True for ops that were in flight when a connection died: the
+     * server may have stored them with the ack getting lost in the disconnect,
+     * or may never have received them. Until the (re-sent) op's ack arrives,
+     * the client cannot know which, so optimistic predictions that assume the
+     * op has not been processed yet are unsound for these ops.
+     */
+    isPossiblyStored(opId: string): boolean;
 }
 
+type DispatchOptions = {
+    /**
+     * Whether this dispatch should clear the redo stack. Defaults to true when
+     * any forward ops are included (a fresh local mutation), false otherwise.
+     * LiveText uses this to dispatch queued ops after an acknowledgement
+     * (which should not clear redo), and to register fresh local edits that
+     * don't carry wire ops yet (which should).
+     */
+    clearRedoStack?: boolean;
+};
 /**
  * The managed pool is a namespace registry (i.e. a context) that "owns" all
  * the individual live nodes, ensuring each one has a unique ID, and holding on
@@ -899,7 +1214,7 @@ interface ManagedPool {
      * - Add reverse operations to the undo/redo stack
      * - Notify room subscribers with updates (in-client, no networking)
      */
-    dispatch: (ops: ClientWireOp[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
+    dispatch: (ops: ClientWireOp[], reverseOps: Op[], storageUpdates: Map<string, StorageUpdate>, options?: DispatchOptions) => void;
     /**
      * Ensures storage can be written to else throws an error.
      * This is used to prevent writing to storage when the user does not have
@@ -924,7 +1239,7 @@ type CreateManagedPoolOptions = {
     /**
      * Will get invoked when any Live structure calls .dispatch() on the pool.
      */
-    onDispatch?: (ops: ClientWireOp[], reverse: Op[], storageUpdates: Map<string, StorageUpdate>) => void;
+    onDispatch?: (ops: ClientWireOp[], reverse: Op[], storageUpdates: Map<string, StorageUpdate>, options?: DispatchOptions) => void;
     /**
      * Will get invoked when any Live structure calls .assertStorageIsWritable()
      * on the pool. Defaults to true when not provided. Return false if you want
@@ -1104,7 +1419,7 @@ declare class LiveRegister<TValue extends Json> extends AbstractCrdt {
     clone(): TValue;
 }
 
-type LiveStructure = LiveObject<LsonObject> | LiveList<Lson> | LiveMap<string, Lson>;
+type LiveStructure = LiveObject<LsonObject> | LiveList<Lson> | LiveMap<string, Lson> | LiveText;
 /**
  * Think of Lson as a sibling of the Json data tree, except that the nested
  * data structure can contain a mix of Json values and LiveStructure instances.
@@ -1140,7 +1455,7 @@ type ToJson<L extends Lson | LsonObject> = L extends LiveList<infer I extends Ls
     readonly [K in keyof O]: ToJson<Exclude<O[K], undefined>> | (undefined extends O[K] ? undefined : never);
 } : L extends LiveMap<infer KS extends string, infer V extends Lson> ? Lson extends V ? ReadonlyJsonObject : {
     readonly [K in KS]: ToJson<V>;
-} : L extends LsonObject ? string extends keyof L ? ReadonlyJsonObject : {
+} : L extends LiveText ? LiveTextData : L extends LsonObject ? string extends keyof L ? ReadonlyJsonObject : {
     readonly [K in keyof L]: ToJson<Exclude<L[K], undefined>> | (undefined extends L[K] ? undefined : never);
 } : L extends Json ? L : never;
 
@@ -1677,7 +1992,7 @@ interface RoomHttpApi<TM extends BaseMetadata, CM extends BaseMetadata> {
         subscriptions: SubscriptionData[];
         requestedAt: Date;
         nextCursor: string | null;
-        permissionHints: Record<string, Permission[]>;
+        permissionHints: Record<string, RoomPermissions>;
     }>;
     getThreadsSince(options: {
         roomId: string;
@@ -1697,7 +2012,7 @@ interface RoomHttpApi<TM extends BaseMetadata, CM extends BaseMetadata> {
             deleted: SubscriptionDeleteInfo[];
         };
         requestedAt: Date;
-        permissionHints: Record<string, Permission[]>;
+        permissionHints: Record<string, RoomPermissions>;
     }>;
     searchComments(options: {
         roomId: string;
@@ -1816,18 +2131,6 @@ interface RoomHttpApi<TM extends BaseMetadata, CM extends BaseMetadata> {
         signal?: AbortSignal;
     }): Promise<CommentAttachment>;
     getOrCreateAttachmentUrlsStore(roomId: string): BatchStore<string, string>;
-    uploadChatAttachment({ chatId, attachment, signal, }: {
-        chatId: string;
-        attachment: {
-            id: string;
-            file: File;
-        };
-        signal?: AbortSignal;
-    }): Promise<void>;
-    getOrCreateChatAttachmentUrlsStore(chatId: string): BatchStore<string, string>;
-    getChatAttachmentUrl(options: {
-        attachmentId: string;
-    }): Promise<string>;
     createTextMention({ roomId, mentionId, mention, }: {
         roomId: string;
         mentionId: string;
@@ -1959,7 +2262,7 @@ interface LiveblocksHttpApi<TM extends BaseMetadata, CM extends BaseMetadata> ex
         subscriptions: SubscriptionData[];
         nextCursor: string | null;
         requestedAt: Date;
-        permissionHints: Record<string, Permission[]>;
+        permissionHints: Record<string, RoomPermissions>;
     }>;
     getUserThreadsSince_experimental(options: {
         since: Date;
@@ -1978,37 +2281,102 @@ interface LiveblocksHttpApi<TM extends BaseMetadata, CM extends BaseMetadata> ex
             deleted: SubscriptionDeleteInfo[];
         };
         requestedAt: Date;
-        permissionHints: Record<string, Permission[]>;
+        permissionHints: Record<string, RoomPermissions>;
     }>;
     groupsStore: BatchStore<GroupData | undefined, string>;
     getGroup(groupId: string): Promise<GroupData | undefined>;
 }
 
-/**
- * Use this symbol to brand an object property as internal.
- *
- * @example
- * Object.defineProperty(
- *   {
- *     public,
- *     [kInternal]: {
- *       private
- *     },
- *   },
- *   kInternal,
- *   {
- *     enumerable: false,
- *   }
- * );
- */
-declare const kInternal: unique symbol;
-
 /**
  * Back-port of TypeScript 5.4's built-in NoInfer utility type.
  * See https://stackoverflow.com/a/56688073/148872
  */
 type NoInfr<A> = [A][A extends any ? 0 : never];
 
+declare const kTrigger: unique symbol;
+/**
+ * Runs a callback function that is allowed to change multiple signals. At the
+ * end of the batch, all changed signals will be notified (at most once).
+ *
+ * Nesting batches is supported.
+ */
+declare function batch(callback: Callback<void>): void;
+type SignalType<S extends ISignal<any>> = S extends ISignal<infer T> ? T : never;
+interface ISignal<T> {
+    get(): T;
+    subscribe(callback: Callback<void>): UnsubscribeCallback;
+    addSink(sink: DerivedSignal<unknown>): void;
+    removeSink(sink: DerivedSignal<unknown>): void;
+}
+/**
+ * Base functionality every Signal implementation needs.
+ */
+declare abstract class AbstractSignal<T> implements ISignal<T>, Observable<void> {
+    #private;
+    constructor(equals?: (a: T, b: T) => boolean);
+    dispose(): void;
+    abstract get(): T;
+    get hasWatchers(): boolean;
+    [kTrigger](): void;
+    subscribe(callback: Callback<void>): UnsubscribeCallback;
+    subscribeOnce(callback: Callback<void>): UnsubscribeCallback;
+    waitUntil(): never;
+    markSinksDirty(): void;
+    addSink(sink: DerivedSignal<unknown>): void;
+    removeSink(sink: DerivedSignal<unknown>): void;
+    asReadonly(): ISignal<T>;
+}
+declare class Signal<T> extends AbstractSignal<T> {
+    #private;
+    constructor(value: T, equals?: (a: T, b: T) => boolean);
+    dispose(): void;
+    get(): T;
+    set(newValue: T | ((oldValue: T) => T)): void;
+}
+declare class DerivedSignal<T> extends AbstractSignal<T> {
+    #private;
+    static from<Ts extends unknown[], V>(...args: [...signals: {
+        [K in keyof Ts]: ISignal<Ts[K]>;
+    }, transform: (...values: Ts) => V]): DerivedSignal<V>;
+    static from<Ts extends unknown[], V>(...args: [...signals: {
+        [K in keyof Ts]: ISignal<Ts[K]>;
+    }, transform: (...values: Ts) => V, equals: (a: V, b: V) => boolean]): DerivedSignal<V>;
+    private constructor();
+    dispose(): void;
+    get isDirty(): boolean;
+    markDirty(): void;
+    get(): T;
+    /**
+     * Called by the Signal system if one or more of the dependent signals have
+     * changed. In the case of a DerivedSignal, we'll only want to re-evaluate
+     * the actual value if it's being watched, or any of their sinks are being
+     * watched actively.
+     */
+    [kTrigger](): void;
+}
+/**
+ * A MutableSignal is a bit like Signal, except its state is managed by
+ * a single value whose reference does not change but is mutated.
+ *
+ * Similar to how useSyncExternalState() works in React, there is a way to read
+ * the current state at any point in time synchronously, and a way to update
+ * its reference.
+ */
+declare class MutableSignal<T extends object> extends AbstractSignal<T> {
+    #private;
+    constructor(initialState: T);
+    dispose(): void;
+    get(): T;
+    /**
+     * Invokes a callback function that is allowed to mutate the given state
+     * value. Do not change the value outside of the callback.
+     *
+     * If the callback explicitly returns `false`, it's assumed that the state
+     * was not changed.
+     */
+    mutate(callback?: (state: T) => void | boolean): void;
+}
+
 type Awaitable<T> = T | PromiseLike<T>;
 
 type AiConnectionErrorContext = {
@@ -2140,11 +2508,6 @@ type EnterOptions<P extends JsonObject = DP, S extends LsonObject = DS> = Resolv
      * the authentication endpoint or connect via WebSocket.
      */
     autoConnect?: boolean;
-    /**
-     * @deprecated This flag no longer has any effect and will be removed in
-     * a future version. All rooms now use the v2 storage engine by default.
-     */
-    engine?: 1 | 2;
 } & PartialUnless<P, {
     /**
      * The initial Presence to use and announce when you enter the Room. The
@@ -2452,12 +2815,6 @@ type ClientOptions<U extends BaseUserMeta = DU> = {
     lostConnectionTimeout?: number;
     backgroundKeepAliveTimeout?: number;
     polyfills?: Polyfills;
-    /**
-     * @deprecated All rooms will be migrated to the v2 storage engine in the
-     * future, which has native support for streaming. After that migration, this
-     * flag will no longer have any effect and will be removed in a future version.
-     */
-    unstable_streamData?: boolean;
     /**
      * A function that returns a list of mention suggestions matching a string.
      */
@@ -3667,10 +4024,15 @@ type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extends BaseUs
     }>;
     /**
      * Get the room's storage synchronously.
-     * The storage's root is a {@link LiveObject}.
+     * The storage's root is a LiveObject.
      *
      * @example
-     * const root = room.getStorageSnapshot();
+     * const root = room.getStorageOrNull();
+     */
+    getStorageOrNull(): LiveObject<S> | null;
+    /**
+     * @deprecated Renamed to `Room.getStorageOrNull`. This alias will be
+     * removed in the future.
      */
     getStorageSnapshot(): LiveObject<S> | null;
     /**
@@ -3787,7 +4149,7 @@ type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extends BaseUs
         subscriptions: SubscriptionData[];
         requestedAt: Date;
         nextCursor: string | null;
-        permissionHints: Record<string, Permission[]>;
+        permissionHints: Record<string, RoomPermissions>;
     }>;
     /**
      * Returns the updated and deleted threads and their associated inbox notifications and subscriptions since the requested date.
@@ -3811,7 +4173,7 @@ type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extends BaseUs
             deleted: SubscriptionDeleteInfo[];
         };
         requestedAt: Date;
-        permissionHints: Record<string, Permission[]>;
+        permissionHints: Record<string, RoomPermissions>;
     }>;
     /**
      * Returns a thread and the associated inbox notification and subscription if it exists.
@@ -4055,7 +4417,14 @@ interface SyncSource {
  */
 type PrivateRoomApi = {
     presenceBuffer: Json | undefined;
-    undoStack: readonly (readonly Readonly<Stackframe<JsonObject>>[])[];
+    undoStack: readonly {
+        readonly id: number;
+        readonly frames: readonly Readonly<Stackframe<JsonObject>>[];
+    }[];
+    redoStack: readonly {
+        readonly id: number;
+        readonly frames: readonly Readonly<Stackframe<JsonObject>>[];
+    }[];
     nodeCount: number;
     getYjsProvider(): IYjsProvider | undefined;
     setYjsProvider(provider: IYjsProvider | undefined): void;
@@ -4090,6 +4459,21 @@ type PrivateRoomApi = {
         incomingMessage(data: string): void;
     };
     attachmentUrlsStore: BatchStore<string, string>;
+    readonly history: Observable<{
+        action: "push";
+        id: number;
+    } | {
+        action: "undo";
+        id: number;
+    } | {
+        action: "redo";
+        id: number;
+    } | {
+        action: "clear";
+    } | {
+        action: "discard";
+        ids: number[];
+    }>;
 };
 type Stackframe<P extends JsonObject> = Op | PresenceStackframe<P>;
 type PresenceStackframe<P extends JsonObject> = {
@@ -4103,7 +4487,7 @@ type StaticSessionInfo = {
 type DynamicSessionInfo = {
     readonly actor: number;
     readonly nonce: string;
-    readonly scopes: string[];
+    readonly permissionMatrix: PermissionMatrix;
     readonly meta: JsonObject;
 };
 type Polyfills = {
@@ -4989,7 +5373,12 @@ type PlainLsonList = {
     liveblocksType: "LiveList";
     data: PlainLson[];
 };
-type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
+type PlainLsonText = {
+    liveblocksType: "LiveText";
+    data: LiveTextData;
+    version?: number;
+};
+type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | PlainLsonText | Json;
 
 /**
  * Returns PlainLson for a given Json or LiveStructure, suitable for calling the storage init api
@@ -5704,4 +6093,4 @@ type EnsureJson<T> = T extends Json ? T : T extends Array<infer I> ? (EnsureJson
     [K in keyof T as EnsureJson<T[K]> extends never ? never : K]: EnsureJson<T[K]>;
 };
 
-export { type ActivityData, type AiAssistantContentPart, type AiAssistantMessage, type AiChat, type AiChatMessage, type AiChatsQuery, type AiKnowledgeRetrievalPart, type AiKnowledgeSource, type AiOpaqueToolDefinition, type AiOpaqueToolInvocationProps, type AiReasoningPart, type AiRetrievalPart, type AiSourcesPart, type AiTextPart, type AiToolDefinition, type AiToolExecuteCallback, type AiToolExecuteContext, type AiToolInvocationPart, type AiToolInvocationProps, type AiToolTypePack, type AiUrlSource, type AiUserMessage, type AiWebRetrievalPart, type AsyncError, type AsyncLoading, type AsyncResult, type AsyncSuccess, type Awaitable, type BaseActivitiesData, type BaseAuthResult, type BaseGroupInfo, type BaseMetadata, type BaseRoomInfo, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type ChildStorageNode, type Client, type ClientMsg, ClientMsgCode, type ClientOptions, type ClientWireOp, type CommentAttachment, type CommentBody, type CommentBodyBlockElement, type CommentBodyElement, type CommentBodyInlineElement, type CommentBodyLink, type CommentBodyLinkElementArgs, type CommentBodyMention, type CommentBodyMentionElementArgs, type CommentBodyParagraph, type CommentBodyParagraphElementArgs, type CommentBodyText, type CommentBodyTextElementArgs, type CommentData, type CommentDataPlain, type CommentLocalAttachment, type CommentMixedAttachment, type CommentReaction, type CommentUserReaction, type CommentUserReactionPlain, type CommentsEventServerMsg, type CompactChildNode, type CompactListNode, type CompactMapNode, type CompactNode, type CompactObjectNode, type CompactRegisterNode, type CompactRootNode, type ContextualPromptContext, type ContextualPromptResponse, type CopilotId, CrdtType, type CreateListOp, type CreateManagedPoolOptions, type CreateMapOp, type CreateObjectOp, type CreateOp, type CreateRegisterOp, type Cursor, type CustomAuthenticationResult, type DAD, type DCM, type DE, type DFM, type DFMD, type DGI, type DP, type DRI, type DS, type DTM, type DU, DefaultMap, type Delegates, type DeleteCrdtOp, type DeleteObjectKeyOp, Deque, DerivedSignal, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, type DistributiveOmit, type EnsureJson, type EnterOptions, type EventSource, type Feed, type FeedCreateMetadata, type FeedDeletedServerMsg, type FeedFetchMetadataFilter, type FeedMessage, type FeedMessagesAddedServerMsg, type FeedMessagesDeletedServerMsg, type FeedMessagesListServerMsg, type FeedMessagesUpdatedServerMsg, type FeedRequestError, FeedRequestErrorCode, type FeedRequestFailedServerMsg, type FeedUpdateMetadata, type FeedsAddedServerMsg, type FeedsEventServerMsg, type FeedsListServerMsg, type FeedsUpdatedServerMsg, type FetchStorageClientMsg, type FetchYDocClientMsg, type GetThreadsOptions, type GroupData, type GroupDataPlain, type GroupMemberData, type GroupMentionData, type GroupScopes, type HasOpId, type History, type HistoryVersion, HttpError, type ISODateString, type ISignal, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IYjsProvider, type IgnoredOp, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type InboxNotificationTextMentionData, type InboxNotificationTextMentionDataPlain, type InboxNotificationThreadData, type InboxNotificationThreadDataPlain, type InferFromSchema, type Json, type JsonArray, type JsonObject, type JsonScalar, type KDAD, type LayerKey, type ListStorageNode, LiveList, type LiveListUpdate, LiveMap, type LiveMapUpdate, type LiveNode, LiveObject, type LiveObjectUpdate, type LiveStructure, LiveblocksError, type LiveblocksErrorContext, type LostConnectionEvent, type Lson, type LsonObject, MENTION_CHARACTER, type ManagedPool, type MapStorageNode, type MentionData, type MessageId, MutableSignal, type NoInfr, type NodeMap, type NodeStream, type NotificationChannel, type NotificationChannelSettings, type NotificationKind, type NotificationSettings, type NotificationSettingsPlain, type ObjectStorageNode, type Observable, type Op, OpCode, type OpaqueClient, type OpaqueRoom, type OptionalTupleUnless, type OthersEvent, type ParentToChildNodeMap, type PartialNotificationSettings, type PartialUnless, type Patchable, Permission, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type Poller, type PrivateClientApi, type PrivateRoomApi, Promise_withResolvers, type QueryMetadata, type QueryParams, type ReadonlyJson, type ReadonlyJsonObject, type RegisterStorageNode, type RejectedStorageOpServerMsg, type Relax, type RenderableToolResultResponse, type Resolve, type ResolveGroupsInfoArgs, type ResolveMentionSuggestionsArgs, type ResolveRoomsInfoArgs, type ResolveUsersArgs, type Room, type RoomEventMessage, type RoomStateServerMsg, type RoomSubscriptionSettings, type RootStorageNode, type SearchCommentsResult, type SerializedChild, type SerializedCrdt, type SerializedList, type SerializedMap, type SerializedObject, type SerializedRegister, type SerializedRootObject, type ServerMsg, ServerMsgCode, type ServerWireOp, type SetParentKeyOp, Signal, type SignalType, SortedList, type Status, type StorageChunkServerMsg, type StorageNode, type StorageStatus, type StorageUpdate, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, type SubscriptionData, type SubscriptionDataPlain, type SubscriptionDeleteInfo, type SubscriptionDeleteInfoPlain, type SubscriptionKey, type SyncConfig, type SyncMode, type SyncSource, type SyncStatus, TextEditorType, type ThreadData, type ThreadDataPlain, type ThreadDataWithDeleteInfo, type ThreadDeleteInfo, type ToJson, type ToolResultResponse, type URLSafeString, type UnsubscribeCallback, type UpdateObjectOp, type UpdatePresenceClientMsg, type UpdatePresenceServerMsg, type UpdateStorageClientMsg, type UpdateStorageServerMsg, type UpdateYDocClientMsg, type UploadAttachmentOptions, type UrlMetadata, type User, type UserJoinServerMsg, type UserLeftServerMsg, type UserMentionData, type UserRoomSubscriptionSettings, type UserSubscriptionData, type UserSubscriptionDataPlain, WebsocketCloseCodes, type WithNavigation, type WithOptional, type WithRequired, type YDocUpdateServerMsg, type YjsSyncStatus, asPos, assert, assertNever, autoRetry, b64decode, batch, checkBounds, chunk, cloneLson, compactNodesToNodeStream, compactObject, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToGroupData, convertToInboxNotificationData, convertToSubscriptionData, convertToThreadData, convertToUserSubscriptionData, createClient, createCommentAttachmentId, createCommentId, createInboxNotificationId, createManagedPool, createNotificationSettings, createThreadId, defineAiTool, deprecate, deprecateIf, detectDupes, entries, errorIf, findLastIndex, freeze, generateUrl, getMentionsFromCommentBody, getSubscriptionKey, html, htmlSafe, isCommentBodyLink, isCommentBodyMention, isCommentBodyText, isJsonArray, isJsonObject, isJsonScalar, isListStorageNode, isLiveNode, isMapStorageNode, isNotificationChannelEnabled, isNumberOperator, isObjectStorageNode, isPlainObject, isRegisterStorageNode, isRootStorageNode, isStartsWithOperator, isUrl, kInternal, keys, makeAbortController, makeEventSource, makePoller, makePosition, mapValues, memoizeOnSuccess, nanoid, nn, nodeStreamToCompactNodes, objectToQuery, patchNotificationSettings, raise, resolveMentionsInCommentBody, sanitizeUrl, shallow, shallow2, stableStringify, stringifyCommentBody, throwUsageError, toPlainLson, tryParseJson, url, urljoin, wait, warnOnce, warnOnceIf, withTimeout };
+export { type AccessLevel, type ActivityData, type AiAssistantContentPart, type AiAssistantMessage, type AiChat, type AiChatMessage, type AiChatsQuery, type AiKnowledgeRetrievalPart, type AiKnowledgeSource, type AiOpaqueToolDefinition, type AiOpaqueToolInvocationProps, type AiReasoningPart, type AiRetrievalPart, type AiSourcesPart, type AiTextPart, type AiToolDefinition, type AiToolExecuteCallback, type AiToolExecuteContext, type AiToolInvocationPart, type AiToolInvocationProps, type AiToolTypePack, type AiUrlSource, type AiUserMessage, type AiWebRetrievalPart, type AsyncError, type AsyncLoading, type AsyncResult, type AsyncSuccess, type Awaitable, type BaseActivitiesData, type BaseAuthResult, type BaseGroupInfo, type BaseMetadata, type BaseRoomInfo, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type ChildStorageNode, type Client, type ClientMsg, ClientMsgCode, type ClientOptions, type ClientWireOp, type CommentAttachment, type CommentBody, type CommentBodyBlockElement, type CommentBodyElement, type CommentBodyInlineElement, type CommentBodyLink, type CommentBodyLinkElementArgs, type CommentBodyMention, type CommentBodyMentionElementArgs, type CommentBodyParagraph, type CommentBodyParagraphElementArgs, type CommentBodyText, type CommentBodyTextElementArgs, type CommentData, type CommentDataPlain, type CommentLocalAttachment, type CommentMixedAttachment, type CommentReaction, type CommentUserReaction, type CommentUserReactionPlain, type CommentsEventServerMsg, type CompactChildNode, type CompactListNode, type CompactMapNode, type CompactNode, type CompactObjectNode, type CompactRegisterNode, type CompactRootNode, type CompactTextNode, type ContextualPromptContext, type ContextualPromptResponse, type CopilotId, CrdtType, type CreateListOp, type CreateManagedPoolOptions, type CreateMapOp, type CreateObjectOp, type CreateOp, type CreateRegisterOp, type CreateTextOp, type Cursor, type CustomAuthenticationResult, type DAD, type DCM, type DE, type DFM, type DFMD, type DGI, type DP, type DRI, type DS, type DTM, type DU, DefaultMap, type Delegates, type DeleteCrdtOp, type DeleteObjectKeyOp, Deque, DerivedSignal, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, type DistributiveOmit, type EnsureJson, type EnterOptions, type EventSource, type Feed, type FeedCreateMetadata, type FeedDeletedServerMsg, type FeedFetchMetadataFilter, type FeedMessage, type FeedMessagesAddedServerMsg, type FeedMessagesDeletedServerMsg, type FeedMessagesListServerMsg, type FeedMessagesUpdatedServerMsg, type FeedRequestError, FeedRequestErrorCode, type FeedRequestFailedServerMsg, type FeedUpdateMetadata, type FeedsAddedServerMsg, type FeedsEventServerMsg, type FeedsListServerMsg, type FeedsUpdatedServerMsg, type FetchStorageClientMsg, type FetchYDocClientMsg, type GetThreadsOptions, type GroupData, type GroupDataPlain, type GroupMemberData, type GroupMentionData, type GroupScopes, type HasOpId, type History, type HistoryVersion, HttpError, type ISODateString, type ISignal, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IYjsProvider, type IgnoredOp, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type InboxNotificationTextMentionData, type InboxNotificationTextMentionDataPlain, type InboxNotificationThreadData, type InboxNotificationThreadDataPlain, type InferFromSchema, type Json, type JsonArray, type JsonObject, type JsonScalar, type KDAD, type LayerKey, type ListStorageNode, LiveList, type LiveListUpdate, LiveMap, type LiveMapUpdate, type LiveNode, LiveObject, type LiveObjectUpdate, type LiveStructure, LiveText, type LiveTextAttributes, type LiveTextAttributesPatch, type LiveTextChange, type LiveTextData, type TextOperation as LiveTextOperation, type LiveTextSegment, type LiveTextUpdate, type LiveTextUpdates, LiveblocksError, type LiveblocksErrorContext, type LostConnectionEvent, type Lson, type LsonObject, MENTION_CHARACTER, type ManagedPool, type MapStorageNode, type MentionData, type MessageId, MutableSignal, type NoInfr, type NodeMap, type NodeStream, type NotificationChannel, type NotificationChannelSettings, type NotificationKind, type NotificationSettings, type NotificationSettingsPlain, type ObjectStorageNode, type Observable, type Op, OpCode, type OpaqueClient, type OpaqueRoom, type OptionalTupleUnless, type OthersEvent, type ParentToChildNodeMap, type PartialNotificationSettings, type PartialUnless, type Patchable, Permission, type PermissionMatrix, type PermissionResources, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type PlainLsonText, type Poller, type PrivateClientApi, type PrivateLiveTextApi, type PrivateRoomApi, Promise_withResolvers, type QueryMetadata, type QueryParams, type ReadonlyJson, type ReadonlyJsonObject, type RegisterStorageNode, type RejectedStorageOpServerMsg, type Relax, type RenderableToolResultResponse, type RequiredAccessLevel, type Resolve, type ResolveGroupsInfoArgs, type ResolveMentionSuggestionsArgs, type ResolveRoomsInfoArgs, type ResolveUsersArgs, type Room, type RoomAccesses, type RoomEventMessage, type RoomPermissions, type RoomStateServerMsg, type RoomSubscriptionSettings, type RootStorageNode, type SearchCommentsResult, type SerializedChild, type SerializedCrdt, type SerializedList, type SerializedMap, type SerializedObject, type SerializedRegister, type SerializedRootObject, type SerializedText, type ServerMsg, ServerMsgCode, type ServerWireOp, type SetParentKeyOp, Signal, type SignalType, SortedList, type Status, type StorageChunkServerMsg, type StorageNode, type StorageStatus, type StorageUpdate, type StorageUpdateSource, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, type SubscriptionData, type SubscriptionDataPlain, type SubscriptionDeleteInfo, type SubscriptionDeleteInfoPlain, type SubscriptionKey, type SyncConfig, type SyncMode, type SyncSource, type SyncStatus, type TextAttributes, TextEditorType, type TextOperation, type TextStorageNode, type ThreadData, type ThreadDataPlain, type ThreadDataWithDeleteInfo, type ThreadDeleteInfo, type ToJson, type ToolResultResponse, type URLSafeString, type UnsubscribeCallback, type UpdateObjectOp, type UpdatePresenceClientMsg, type UpdatePresenceServerMsg, type UpdateRoomAccesses, type UpdateStorageClientMsg, type UpdateStorageServerMsg, type UpdateTextOp, type UpdateYDocClientMsg, type UploadAttachmentOptions, type UrlMetadata, type User, type UserJoinServerMsg, type UserLeftServerMsg, type UserMentionData, type UserRoomSubscriptionSettings, type UserSubscriptionData, type UserSubscriptionDataPlain, WebsocketCloseCodes, type WithNavigation, type WithOptional, type WithRequired, type YDocUpdateServerMsg, type YjsSyncStatus, applyLiveTextOperations, asPos, assert, assertNever, autoRetry, b64decode, batch, checkBounds, chunk, cloneLson, compactNodesToNodeStream, compactObject, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToGroupData, convertToInboxNotificationData, convertToSubscriptionData, convertToThreadData, convertToUserSubscriptionData, createClient, createCommentAttachmentId, createCommentId, createInboxNotificationId, createManagedPool, createNotificationSettings, createThreadId, deepLiveify, defineAiTool, deprecate, deprecateIf, detectDupes, entries, errorIf, findLastIndex, freeze, generateUrl, getMentionsFromCommentBody, getSubscriptionKey, hasPermissionAccess, html, htmlSafe, isCommentBodyLink, isCommentBodyMention, isCommentBodyText, isJsonArray, isJsonObject, isJsonScalar, isListStorageNode, isLiveNode, isMapStorageNode, isNotificationChannelEnabled, isNumberOperator, isObjectStorageNode, isPlainObject, isRegisterStorageNode, isRootStorageNode, isStartsWithOperator, isTextStorageNode, isUrl, kInternal, kStorageUpdateSource, keys, makeAbortController, makeEventSource, makePoller, makePosition, mapValues, memoizeOnSuccess, mergeRoomPermissionScopes, nanoid, nn, nodeStreamToCompactNodes, normalizeRoomAccesses, normalizeRoomPermissions, normalizeUpdateRoomAccesses, objectToQuery, patchNotificationSettings, permissionMatrixFromScopes, raise, resolveMentionsInCommentBody, sanitizeUrl, shallow, shallow2, stableStringify, stringifyCommentBody, throwUsageError, toPlainLson, transformTextOperations, tryParseJson, url, urljoin, validatePermissionsSet, wait, warnOnce, warnOnceIf, withTimeout };