@liveblocks/core 1.0.7 → 1.0.9

package/dist/index.d.ts

@@ -129,6 +129,63 @@ declare type UpdateDelta = {
     type: "delete";
 };
 
+/**
+ * "Plain LSON" is a JSON-based format that's used when serializing Live structures
+ * to send them over HTTP (e.g. in the API endpoint to let users upload their initial
+ * Room storage, in the API endpoint to fetch a Room's storage, ...).
+ *
+ * In the client, you would typically create LSON values using:
+ *
+ *    new LiveObject({ x: 0, y: 0 })
+ *
+ * But over HTTP, this has to be serialized somehow. The "Plain LSON" format
+ * is what's used in the POST /init-storage-new endpoint, to allow users to
+ * control which parts of their data structure should be considered "Live"
+ * objects, and which parts are "normal" objects.
+ *
+ * So if they have a structure like:
+ *
+ *    { x: 0, y: 0 }
+ *
+ * And want to make it a Live object, they can serialize it by wrapping it in
+ * a special "annotation":
+ *
+ *    {
+ *      "liveblocksType": "LiveObject",
+ *      "data": { x: 0, y: 0 },
+ *    }
+ *
+ * This "Plain LSON" data format defines exactly those wrappings.
+ *
+ * To summarize:
+ *
+ *   LSON value            |  Plain LSON equivalent
+ *   ----------------------+----------------------------------------------
+ *   42                    |  42
+ *   [1, 2, 3]             |  [1, 2, 3]
+ *   { x: 0, y: 0 }        |  { x: 0, y: 0 }
+ *   ----------------------+----------------------------------------------
+ *   new LiveList(...)     |  { liveblocksType: "LiveList",   data: ... }
+ *   new LiveMap(...)      |  { liveblocksType: "LiveMap",    data: ... }
+ *   new LiveObject(...)   |  { liveblocksType: "LiveObject", data: ... }
+ *
+ */
+
+declare type PlainLsonFields = Record<string, PlainLson>;
+declare type PlainLsonObject = {
+    liveblocksType: "LiveObject";
+    data: PlainLsonFields;
+};
+declare type PlainLsonMap = {
+    liveblocksType: "LiveMap";
+    data: PlainLsonFields;
+};
+declare type PlainLsonList = {
+    liveblocksType: "LiveList";
+    data: PlainLson[];
+};
+declare type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
+
 declare type LiveObjectUpdateDelta<O extends {
     [key: string]: unknown;
 }> = {
@@ -197,6 +254,10 @@ declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
 declare type ToImmutable<L extends Lson | LsonObject> = L extends LiveList<infer I> ? readonly ToImmutable<I>[] : L extends LiveObject<infer O> ? ToImmutable<O> : L extends LiveMap<infer K, infer V> ? ReadonlyMap<K, ToImmutable<V>> : L extends LsonObject ? {
     readonly [K in keyof L]: ToImmutable<Exclude<L[K], undefined>> | (undefined extends L[K] ? undefined : never);
 } : L extends Json ? L : never;
+/**
+ * Returns PlainLson for a given Json or LiveStructure, suitable for calling the storage init api
+ */
+declare function toPlainLson(lson: Lson): PlainLson;
 
 /**
  * A LiveMap notification that is sent in-client to any subscribers whenever
@@ -268,12 +329,15 @@ declare class LiveMap<TKey extends string, TValue extends Lson> extends Abstract
 }
 
 declare type StorageCallback = (updates: StorageUpdate[]) => void;
+declare type LiveMapUpdate = LiveMapUpdates<string, Lson>;
+declare type LiveObjectUpdate = LiveObjectUpdates<LsonObject>;
+declare type LiveListUpdate = LiveListUpdates<Lson>;
 /**
  * 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.
  */
-declare type StorageUpdate = LiveMapUpdates<string, Lson> | LiveObjectUpdates<LsonObject> | LiveListUpdates<Lson>;
+declare type StorageUpdate = LiveMapUpdate | LiveObjectUpdate | LiveListUpdate;
 
 declare abstract class AbstractCrdt {
     get roomId(): string | null;
@@ -508,78 +572,54 @@ declare type Observable<T> = {
     subscribeOnce(callback: Callback<T>): UnsubscribeCallback;
 };
 
-declare type AppOnlyAuthToken = {
-    appId: string;
-    roomId?: never;
-    scopes: string[];
-};
-declare type RoomAuthToken = {
-    appId: string;
-    roomId: string;
-    scopes: string[];
-    actor: number;
-    maxConnectionsPerRoom?: number;
-    info?: Json;
-    groupIds?: string[];
-} & ({
-    id: string;
-    anonymousId?: never;
-} | {
-    id?: never;
-    anonymousId: string;
-});
-declare type AuthToken = AppOnlyAuthToken | RoomAuthToken;
-declare function isAppOnlyAuthToken(data: JsonObject): data is AppOnlyAuthToken;
-declare function isRoomAuthToken(data: JsonObject): data is RoomAuthToken;
-declare function isAuthToken(data: JsonObject): data is AuthToken;
-
-declare enum ClientMsgCode {
-    UPDATE_PRESENCE = 100,
-    BROADCAST_EVENT = 103,
-    FETCH_STORAGE = 200,
-    UPDATE_STORAGE = 201
+interface IWebSocketEvent {
+    type: string;
+}
+interface IWebSocketCloseEvent extends IWebSocketEvent {
+    readonly code: number;
+    readonly wasClean: boolean;
+    readonly reason: string;
+}
+interface IWebSocketMessageEvent extends IWebSocketEvent {
+    readonly data: string | Buffer | ArrayBuffer | readonly Buffer[];
+}
+interface IWebSocketInstance {
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    readonly CLOSING: number;
+    readonly CLOSED: number;
+    readonly readyState: number;
+    addEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
+    addEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
+    addEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
+    removeEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
+    removeEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
+    removeEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
+    close(): void;
+    send(data: string): void;
 }
 /**
- * Messages that can be sent from the client to the server.
+ * Either the browser-based WebSocket API or Node.js' WebSocket API (from the
+ * 'ws' package).
+ *
+ * This type defines the minimal WebSocket API that Liveblocks needs from
+ * a WebSocket implementation, and is a minimal subset of the browser-based
+ * WebSocket APIs and Node.js' WebSocket API so that both implementations are
+ * assignable to this type.
  */
-declare type ClientMsg<TPresence extends JsonObject, TRoomEvent extends Json> = BroadcastEventClientMsg<TRoomEvent> | UpdatePresenceClientMsg<TPresence> | UpdateStorageClientMsg | FetchStorageClientMsg;
-declare type BroadcastEventClientMsg<TRoomEvent extends Json> = {
-    type: ClientMsgCode.BROADCAST_EVENT;
-    event: TRoomEvent;
-};
-declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
-    readonly type: ClientMsgCode.UPDATE_PRESENCE;
-    /**
-     * Set this to any number to signify that this is a Full Presence™
-     * update, not a patch.
-     *
-     * The numeric value itself no longer has specific meaning. Historically,
-     * this field was intended so that clients could ignore these broadcasted
-     * full presence messages, but it turned out that getting a full presence
-     * "keyframe" from time to time was useful.
-     *
-     * So nowadays, the presence (pun intended) of this `targetActor` field
-     * is a backward-compatible way of expressing that the `data` contains
-     * all presence fields, and isn't a partial "patch".
-     */
-    readonly targetActor: number;
-    readonly data: TPresence;
-} | {
-    readonly type: ClientMsgCode.UPDATE_PRESENCE;
-    /**
-     * Absence of the `targetActor` field signifies that this is a Partial
-     * Presence™ "patch".
-     */
-    readonly targetActor?: undefined;
-    readonly data: Partial<TPresence>;
-};
-declare type UpdateStorageClientMsg = {
-    readonly type: ClientMsgCode.UPDATE_STORAGE;
-    readonly ops: Op[];
-};
-declare type FetchStorageClientMsg = {
-    readonly type: ClientMsgCode.FETCH_STORAGE;
-};
+interface IWebSocket {
+    new (address: string): IWebSocketInstance;
+}
+declare enum WebsocketCloseCodes {
+    CLOSE_ABNORMAL = 1006,
+    INVALID_MESSAGE_FORMAT = 4000,
+    NOT_ALLOWED = 4001,
+    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
+    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
+    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
+    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
+    CLOSE_WITHOUT_RETRY = 4999
+}
 
 declare type ReadonlyArrayWithLegacyMethods<T> = readonly T[] & {
     /**
@@ -638,48 +678,6 @@ declare type OthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUse
     type: "reset";
 };
 
-declare type JsonTreeNode = {
-    readonly type: "Json";
-    readonly id: string;
-    readonly key: string;
-    readonly payload: Json;
-};
-declare type LiveTreeNode<TName extends `Live${string}` = `Live${string}`> = {
-    readonly type: TName;
-    readonly id: string;
-    readonly key: string;
-    readonly payload: LsonTreeNode[];
-};
-declare type LsonTreeNode = LiveTreeNode | JsonTreeNode;
-declare type UserTreeNode = {
-    readonly type: "User";
-    readonly id: string;
-    readonly key: string;
-    readonly payload: {
-        readonly connectionId: number;
-        readonly id?: string;
-        readonly info?: Json;
-        readonly presence: JsonObject;
-        readonly isReadOnly: boolean;
-    };
-};
-declare type TreeNode = LsonTreeNode | UserTreeNode;
-
-type DevToolsTreeNode_JsonTreeNode = JsonTreeNode;
-type DevToolsTreeNode_LiveTreeNode<TName extends `Live${string}` = `Live${string}`> = LiveTreeNode<TName>;
-type DevToolsTreeNode_LsonTreeNode = LsonTreeNode;
-type DevToolsTreeNode_UserTreeNode = UserTreeNode;
-type DevToolsTreeNode_TreeNode = TreeNode;
-declare namespace DevToolsTreeNode {
-  export {
-    DevToolsTreeNode_JsonTreeNode as JsonTreeNode,
-    DevToolsTreeNode_LiveTreeNode as LiveTreeNode,
-    DevToolsTreeNode_LsonTreeNode as LsonTreeNode,
-    DevToolsTreeNode_UserTreeNode as UserTreeNode,
-    DevToolsTreeNode_TreeNode as TreeNode,
-  };
-}
-
 declare type CustomEvent<TRoomEvent extends Json> = {
     connectionId: number;
     event: TRoomEvent;
@@ -792,6 +790,128 @@ declare type BroadcastOptions = {
      */
     shouldQueueEventIfNotReady: boolean;
 };
+declare type SubscribeFn<TPresence extends JsonObject, _TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = {
+    /**
+     * Subscribe to the current user presence updates.
+     *
+     * @param listener the callback that is called every time the current user presence is updated with {@link Room.updatePresence}.
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * room.subscribe("my-presence", (presence) => {
+     *   // Do something
+     * });
+     */
+    (type: "my-presence", listener: Callback<TPresence>): () => void;
+    /**
+     * Subscribe to the other users updates.
+     *
+     * @param listener the callback that is called when a user enters or leaves the room or when a user update its presence.
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * room.subscribe("others", (others) => {
+     *   // Do something
+     * });
+     *
+     */
+    (type: "others", listener: (others: Others<TPresence, TUserMeta>, event: OthersEvent<TPresence, TUserMeta>) => void): () => void;
+    /**
+     * Subscribe to events broadcasted by {@link Room.broadcastEvent}
+     *
+     * @param listener the callback that is called when a user calls {@link Room.broadcastEvent}
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * room.subscribe("event", ({ event, connectionId }) => {
+     *   // Do something
+     * });
+     *
+     */
+    (type: "event", listener: Callback<CustomEvent<TRoomEvent>>): () => void;
+    /**
+     * Subscribe to errors thrown in the room.
+     *
+     * @returns Unsubscribe function.
+     *
+     */
+    (type: "error", listener: ErrorCallback): () => void;
+    /**
+     * Subscribe to connection state updates.
+     *
+     * @returns Unsubscribe function.
+     *
+     */
+    (type: "connection", listener: Callback<ConnectionStatus>): () => void;
+    /**
+     * Subscribes to changes made on a Live structure. Returns an unsubscribe function.
+     * In a future version, we will also expose what exactly changed in the Live structure.
+     *
+     * @param callback The callback this called when the Live structure changes.
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * const liveMap = new LiveMap();  // Could also be LiveList or LiveObject
+     * const unsubscribe = room.subscribe(liveMap, (liveMap) => { });
+     * unsubscribe();
+     */
+    <L extends LiveStructure>(liveStructure: L, callback: (node: L) => void): () => void;
+    /**
+     * Subscribes to changes made on a Live structure and all the nested data
+     * structures. Returns an unsubscribe function. In a future version, we
+     * will also expose what exactly changed in the Live structure.
+     *
+     * @param callback The callback this called when the Live structure, or any
+     * of its nested values, changes.
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * const liveMap = new LiveMap();  // Could also be LiveList or LiveObject
+     * const unsubscribe = room.subscribe(liveMap, (updates) => { }, { isDeep: true });
+     * unsubscribe();
+     */
+    <L extends LiveStructure>(liveStructure: L, callback: StorageCallback, options: {
+        isDeep: true;
+    }): () => void;
+    /**
+     * Subscribe to the current user's history changes.
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * room.subscribe("history", ({ canUndo, canRedo }) => {
+     *   // Do something
+     * });
+     */
+    (type: "history", listener: Callback<HistoryEvent>): () => void;
+    /**
+     * Subscribe to storage status changes.
+     *
+     * @returns Unsubscribe function.
+     *
+     * @example
+     * room.subscribe("storage-status", (status) => {
+     *   switch(status) {
+     *      case "not-loaded":
+     *        break;
+     *      case "loading":
+     *        break;
+     *      case "synchronizing":
+     *        break;
+     *      case "synchronized":
+     *        break;
+     *      default:
+     *        break;
+     *   }
+     * });
+     */
+    (type: "storage-status", listener: Callback<StorageStatus>): () => void;
+};
 declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = {
     /**
      * The id of the room.
@@ -803,128 +923,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      */
     isSelfAware(): boolean;
     getConnectionState(): ConnectionStatus;
-    readonly subscribe: {
-        /**
-         * Subscribe to the current user presence updates.
-         *
-         * @param listener the callback that is called every time the current user presence is updated with {@link Room.updatePresence}.
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * room.subscribe("my-presence", (presence) => {
-         *   // Do something
-         * });
-         */
-        (type: "my-presence", listener: Callback<TPresence>): () => void;
-        /**
-         * Subscribe to the other users updates.
-         *
-         * @param listener the callback that is called when a user enters or leaves the room or when a user update its presence.
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * room.subscribe("others", (others) => {
-         *   // Do something
-         * });
-         *
-         */
-        (type: "others", listener: (others: Others<TPresence, TUserMeta>, event: OthersEvent<TPresence, TUserMeta>) => void): () => void;
-        /**
-         * Subscribe to events broadcasted by {@link Room.broadcastEvent}
-         *
-         * @param listener the callback that is called when a user calls {@link Room.broadcastEvent}
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * room.subscribe("event", ({ event, connectionId }) => {
-         *   // Do something
-         * });
-         *
-         */
-        (type: "event", listener: Callback<CustomEvent<TRoomEvent>>): () => void;
-        /**
-         * Subscribe to errors thrown in the room.
-         *
-         * @returns Unsubscribe function.
-         *
-         */
-        (type: "error", listener: ErrorCallback): () => void;
-        /**
-         * Subscribe to connection state updates.
-         *
-         * @returns Unsubscribe function.
-         *
-         */
-        (type: "connection", listener: Callback<ConnectionStatus>): () => void;
-        /**
-         * Subscribes to changes made on a Live structure. Returns an unsubscribe function.
-         * In a future version, we will also expose what exactly changed in the Live structure.
-         *
-         * @param callback The callback this called when the Live structure changes.
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * const liveMap = new LiveMap();  // Could also be LiveList or LiveObject
-         * const unsubscribe = room.subscribe(liveMap, (liveMap) => { });
-         * unsubscribe();
-         */
-        <L extends LiveStructure>(liveStructure: L, callback: (node: L) => void): () => void;
-        /**
-         * Subscribes to changes made on a Live structure and all the nested data
-         * structures. Returns an unsubscribe function. In a future version, we
-         * will also expose what exactly changed in the Live structure.
-         *
-         * @param callback The callback this called when the Live structure, or any
-         * of its nested values, changes.
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * const liveMap = new LiveMap();  // Could also be LiveList or LiveObject
-         * const unsubscribe = room.subscribe(liveMap, (updates) => { }, { isDeep: true });
-         * unsubscribe();
-         */
-        <L extends LiveStructure>(liveStructure: L, callback: StorageCallback, options: {
-            isDeep: true;
-        }): () => void;
-        /**
-         * Subscribe to the current user's history changes.
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * room.subscribe("history", ({ canUndo, canRedo }) => {
-         *   // Do something
-         * });
-         */
-        (type: "history", listener: Callback<HistoryEvent>): () => void;
-        /**
-         * Subscribe to storage status changes.
-         *
-         * @returns Unsubscribe function.
-         *
-         * @example
-         * room.subscribe("storage-status", (status) => {
-         *   switch(status) {
-         *      case "not-loaded":
-         *        break;
-         *      case "loading":
-         *        break;
-         *      case "synchronizing":
-         *        break;
-         *      case "synchronized":
-         *        break;
-         *      default:
-         *        break;
-         *   }
-         * });
-         */
-        (type: "storage-status", listener: Callback<StorageStatus>): () => void;
-    };
+    readonly subscribe: SubscribeFn<TPresence, TStorage, TUserMeta, TRoomEvent>;
     /**
      * Room's history contains functions that let you undo and redo operation made on by the current client on the presence and storage.
      */
@@ -1004,24 +1003,25 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      */
     getStorageSnapshot(): LiveObject<TStorage> | null;
     readonly events: {
-        customEvent: Observable<{
+        readonly customEvent: Observable<{
             connectionId: number;
             event: TRoomEvent;
         }>;
-        me: Observable<TPresence>;
-        others: Observable<{
+        readonly me: Observable<TPresence>;
+        readonly others: Observable<{
             others: Others<TPresence, TUserMeta>;
             event: OthersEvent<TPresence, TUserMeta>;
         }>;
-        error: Observable<Error>;
-        connection: Observable<ConnectionStatus>;
-        storage: Observable<StorageUpdate[]>;
-        history: Observable<HistoryEvent>;
+        readonly error: Observable<Error>;
+        readonly connection: Observable<ConnectionStatus>;
+        readonly storage: Observable<StorageUpdate[]>;
+        readonly history: Observable<HistoryEvent>;
         /**
          * Subscribe to the storage loaded event. Will fire at most once during the
          * lifetime of a Room.
          */
-        storageDidLoad: Observable<void>;
+        readonly storageDidLoad: Observable<void>;
+        readonly storageStatus: Observable<StorageStatus>;
     };
     /**
      * Batches modifications made during the given function.
@@ -1054,7 +1054,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
 declare type Polyfills = {
     atob?: (data: string) => string;
     fetch?: typeof fetch;
-    WebSocket?: any;
+    WebSocket?: IWebSocket;
 };
 declare type RoomInitializers<TPresence extends JsonObject, TStorage extends LsonObject> = Resolve<{
     /**
@@ -1329,6 +1329,79 @@ declare function asPos(str: string): Pos;
  */
 declare function shallow(a: unknown, b: unknown): boolean;
 
+declare type AppOnlyAuthToken = {
+    appId: string;
+    roomId?: never;
+    scopes: string[];
+};
+declare type RoomAuthToken = {
+    appId: string;
+    roomId: string;
+    scopes: string[];
+    actor: number;
+    maxConnectionsPerRoom?: number;
+    info?: Json;
+    groupIds?: string[];
+} & ({
+    id: string;
+    anonymousId?: never;
+} | {
+    id?: never;
+    anonymousId: string;
+});
+declare type AuthToken = AppOnlyAuthToken | RoomAuthToken;
+declare function isAppOnlyAuthToken(data: JsonObject): data is AppOnlyAuthToken;
+declare function isRoomAuthToken(data: JsonObject): data is RoomAuthToken;
+declare function isAuthToken(data: JsonObject): data is AuthToken;
+
+declare enum ClientMsgCode {
+    UPDATE_PRESENCE = 100,
+    BROADCAST_EVENT = 103,
+    FETCH_STORAGE = 200,
+    UPDATE_STORAGE = 201
+}
+/**
+ * Messages that can be sent from the client to the server.
+ */
+declare type ClientMsg<TPresence extends JsonObject, TRoomEvent extends Json> = BroadcastEventClientMsg<TRoomEvent> | UpdatePresenceClientMsg<TPresence> | UpdateStorageClientMsg | FetchStorageClientMsg;
+declare type BroadcastEventClientMsg<TRoomEvent extends Json> = {
+    type: ClientMsgCode.BROADCAST_EVENT;
+    event: TRoomEvent;
+};
+declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
+    readonly type: ClientMsgCode.UPDATE_PRESENCE;
+    /**
+     * Set this to any number to signify that this is a Full Presence™
+     * update, not a patch.
+     *
+     * The numeric value itself no longer has specific meaning. Historically,
+     * this field was intended so that clients could ignore these broadcasted
+     * full presence messages, but it turned out that getting a full presence
+     * "keyframe" from time to time was useful.
+     *
+     * So nowadays, the presence (pun intended) of this `targetActor` field
+     * is a backward-compatible way of expressing that the `data` contains
+     * all presence fields, and isn't a partial "patch".
+     */
+    readonly targetActor: number;
+    readonly data: TPresence;
+} | {
+    readonly type: ClientMsgCode.UPDATE_PRESENCE;
+    /**
+     * Absence of the `targetActor` field signifies that this is a Partial
+     * Presence™ "patch".
+     */
+    readonly targetActor?: undefined;
+    readonly data: Partial<TPresence>;
+};
+declare type UpdateStorageClientMsg = {
+    readonly type: ClientMsgCode.UPDATE_STORAGE;
+    readonly ops: Op[];
+};
+declare type FetchStorageClientMsg = {
+    readonly type: ClientMsgCode.FETCH_STORAGE;
+};
+
 declare type IdTuple<T> = [id: string, value: T];
 declare enum CrdtType {
     OBJECT = 0,
@@ -1537,72 +1610,46 @@ SerializedCrdt>;
 declare type ParentToChildNodeMap = Map<string, // Parent's node ID
 IdTuple<SerializedChild>[]>;
 
-/**
- * "Plain LSON" is a JSON-based format that's used when serializing Live structures
- * to send them over HTTP (e.g. in the API endpoint to let users upload their initial
- * Room storage, in the API endpoint to fetch a Room's storage, ...).
- *
- * In the client, you would typically create LSON values using:
- *
- *    new LiveObject({ x: 0, y: 0 })
- *
- * But over HTTP, this has to be serialized somehow. The "Plain LSON" format
- * is what's used in the POST /init-storage-new endpoint, to allow users to
- * control which parts of their data structure should be considered "Live"
- * objects, and which parts are "normal" objects.
- *
- * So if they have a structure like:
- *
- *    { x: 0, y: 0 }
- *
- * And want to make it a Live object, they can serialize it by wrapping it in
- * a special "annotation":
- *
- *    {
- *      "liveblocksType": "LiveObject",
- *      "data": { x: 0, y: 0 },
- *    }
- *
- * This "Plain LSON" data format defines exactly those wrappings.
- *
- * To summarize:
- *
- *   LSON value            |  Plain LSON equivalent
- *   ----------------------+----------------------------------------------
- *   42                    |  42
- *   [1, 2, 3]             |  [1, 2, 3]
- *   { x: 0, y: 0 }        |  { x: 0, y: 0 }
- *   ----------------------+----------------------------------------------
- *   new LiveList(...)     |  { liveblocksType: "LiveList",   data: ... }
- *   new LiveMap(...)      |  { liveblocksType: "LiveMap",    data: ... }
- *   new LiveObject(...)   |  { liveblocksType: "LiveObject", data: ... }
- *
- */
-
-declare type PlainLsonFields = Record<string, PlainLson>;
-declare type PlainLsonObject = {
-    liveblocksType: "LiveObject";
-    data: PlainLsonFields;
+declare type JsonTreeNode = {
+    readonly type: "Json";
+    readonly id: string;
+    readonly key: string;
+    readonly payload: Json;
 };
-declare type PlainLsonMap = {
-    liveblocksType: "LiveMap";
-    data: PlainLsonFields;
+declare type LiveTreeNode<TName extends `Live${string}` = `Live${string}`> = {
+    readonly type: TName;
+    readonly id: string;
+    readonly key: string;
+    readonly payload: LsonTreeNode[];
 };
-declare type PlainLsonList = {
-    liveblocksType: "LiveList";
-    data: PlainLson[];
+declare type LsonTreeNode = LiveTreeNode | JsonTreeNode;
+declare type UserTreeNode = {
+    readonly type: "User";
+    readonly id: string;
+    readonly key: string;
+    readonly payload: {
+        readonly connectionId: number;
+        readonly id?: string;
+        readonly info?: Json;
+        readonly presence: JsonObject;
+        readonly isReadOnly: boolean;
+    };
 };
-declare type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
+declare type TreeNode = LsonTreeNode | UserTreeNode;
 
-declare enum WebsocketCloseCodes {
-    CLOSE_ABNORMAL = 1006,
-    INVALID_MESSAGE_FORMAT = 4000,
-    NOT_ALLOWED = 4001,
-    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
-    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
-    CLOSE_WITHOUT_RETRY = 4999
+type DevToolsTreeNode_JsonTreeNode = JsonTreeNode;
+type DevToolsTreeNode_LiveTreeNode<TName extends `Live${string}` = `Live${string}`> = LiveTreeNode<TName>;
+type DevToolsTreeNode_LsonTreeNode = LsonTreeNode;
+type DevToolsTreeNode_UserTreeNode = UserTreeNode;
+type DevToolsTreeNode_TreeNode = TreeNode;
+declare namespace DevToolsTreeNode {
+  export {
+    DevToolsTreeNode_JsonTreeNode as JsonTreeNode,
+    DevToolsTreeNode_LiveTreeNode as LiveTreeNode,
+    DevToolsTreeNode_LsonTreeNode as LsonTreeNode,
+    DevToolsTreeNode_UserTreeNode as UserTreeNode,
+    DevToolsTreeNode_TreeNode as TreeNode,
+  };
 }
 
 /**
@@ -1739,4 +1786,4 @@ declare type EnsureJson<T> = [
     [K in keyof T]: EnsureJson<T[K]>;
 };
 
-export { AckOp, AppOnlyAuthToken, AuthToken, BaseUserMeta, BroadcastEventClientMsg, BroadcastOptions, BroadcastedEventServerMsg, Client, ClientMsg, ClientMsgCode, ConnectionStatus, CrdtType, CreateChildOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, CreateRootObjectOp, DeleteCrdtOp, DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, EnsureJson, FetchStorageClientMsg, History, IdTuple, Immutable, InitialDocumentStateServerMsg, Json, JsonArray, JsonObject, JsonScalar, LiveList, LiveMap, LiveNode, LiveObject, LiveStructure, Lson, LsonObject, NodeMap, Op, OpCode, Others, ParentToChildNodeMap, PlainLson, PlainLsonFields, PlainLsonList, PlainLsonMap, PlainLsonObject, RejectedStorageOpServerMsg, Resolve, Room, RoomAuthToken, RoomInitializers, RoomStateServerMsg, SerializedChild, SerializedCrdt, SerializedList, SerializedMap, SerializedObject, SerializedRegister, SerializedRootObject, ServerMsg, ServerMsgCode, SetParentKeyOp, StorageStatus, StorageUpdate, ToImmutable, ToJson, UpdateObjectOp, UpdatePresenceClientMsg, UpdatePresenceServerMsg, UpdateStorageClientMsg, UpdateStorageServerMsg, User, UserJoinServerMsg, UserLeftServerMsg, WebsocketCloseCodes, asArrayWithLegacyMethods, asPos, assert, assertNever, b64decode, createClient, deprecate, deprecateIf, errorIf, freeze, isAppOnlyAuthToken, isAuthToken, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isPlainObject, isRoomAuthToken, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makePosition, nn, patchLiveObjectKey, shallow, throwUsageError, tryParseJson };
+export { AckOp, AppOnlyAuthToken, AuthToken, BaseUserMeta, BroadcastEventClientMsg, BroadcastOptions, BroadcastedEventServerMsg, Client, ClientMsg, ClientMsgCode, ConnectionStatus, CrdtType, CreateChildOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, CreateRootObjectOp, DeleteCrdtOp, DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, EnsureJson, FetchStorageClientMsg, History, IWebSocket, IWebSocketCloseEvent, IWebSocketEvent, IWebSocketInstance, IWebSocketMessageEvent, IdTuple, Immutable, InitialDocumentStateServerMsg, Json, JsonArray, JsonObject, JsonScalar, LiveList, LiveListUpdate, LiveMap, LiveMapUpdate, LiveNode, LiveObject, LiveObjectUpdate, LiveStructure, Lson, LsonObject, NodeMap, Op, OpCode, Others, ParentToChildNodeMap, PlainLson, PlainLsonFields, PlainLsonList, PlainLsonMap, PlainLsonObject, RejectedStorageOpServerMsg, Resolve, Room, RoomAuthToken, RoomInitializers, RoomStateServerMsg, SerializedChild, SerializedCrdt, SerializedList, SerializedMap, SerializedObject, SerializedRegister, SerializedRootObject, ServerMsg, ServerMsgCode, SetParentKeyOp, StorageStatus, StorageUpdate, ToImmutable, ToJson, UpdateObjectOp, UpdatePresenceClientMsg, UpdatePresenceServerMsg, UpdateStorageClientMsg, UpdateStorageServerMsg, User, UserJoinServerMsg, UserLeftServerMsg, WebsocketCloseCodes, asArrayWithLegacyMethods, asPos, assert, assertNever, b64decode, createClient, deprecate, deprecateIf, errorIf, freeze, isAppOnlyAuthToken, isAuthToken, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isPlainObject, isRoomAuthToken, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makePosition, nn, patchLiveObjectKey, shallow, throwUsageError, toPlainLson, tryParseJson };