@liveblocks/core 1.19.0-test1 → 2.0.0-alpha1

package/dist/index.d.mts

@@ -5,6 +5,19 @@
 declare function detectDupes(pkgName: string, pkgVersion: string | false, // false if not built yet
 pkgFormat: string | false): void;
 
+declare type CustomAuthenticationResult = {
+    token: string;
+    error?: never;
+} | {
+    token?: never;
+    error: "forbidden";
+    reason: string;
+} | {
+    token?: never;
+    error: string;
+    reason: string;
+};
+
 /**
  * Represents an indefinitely deep arbitrary JSON data structure. There are
  * four types that make up the Json family:
@@ -25,6 +38,217 @@ declare function isJsonScalar(data: Json): data is JsonScalar;
 declare function isJsonArray(data: Json): data is JsonArray;
 declare function isJsonObject(data: Json): data is JsonObject;
 
+/**
+ * Represents some constraints for user info. Basically read this as: "any JSON
+ * object is fine, but _if_ it has a name field, it _must_ be a string."
+ * (Ditto for avatar.)
+ */
+declare type IUserInfo = {
+    [key: string]: Json | undefined;
+    name?: string;
+    avatar?: string;
+};
+/**
+ * This type is used by clients to define the metadata for a user.
+ */
+declare type BaseUserMeta = {
+    /**
+     * The id of the user that has been set in the authentication endpoint.
+     * Useful to get additional information about the connected user.
+     */
+    id?: string;
+    /**
+     * Additional user information that has been set in the authentication endpoint.
+     */
+    info?: IUserInfo;
+};
+
+declare type Callback<T> = (event: T) => void;
+declare type UnsubscribeCallback = () => void;
+declare type Observable<T> = {
+    /**
+     * Register a callback function to be called whenever the event source emits
+     * an event.
+     */
+    subscribe(callback: Callback<T>): UnsubscribeCallback;
+    /**
+     * Register a one-time callback function to be called whenever the event
+     * source emits an event. After the event fires, the callback is
+     * auto-unsubscribed.
+     */
+    subscribeOnce(callback: Callback<T>): UnsubscribeCallback;
+    /**
+     * Returns a promise that will resolve when an event is emitted by this
+     * event source. Optionally, specify a predicate that has to match. The first
+     * event matching that predicate will then resolve the promise.
+     */
+    waitUntil(predicate?: (event: T) => boolean): Promise<T>;
+};
+declare type EventSource<T> = Observable<T> & {
+    /**
+     * Notify all subscribers about the event.
+     */
+    notify(event: T): void;
+    /**
+     * Clear all registered event listeners. None of the registered functions
+     * will ever get called again. Be careful when using this API, because the
+     * subscribers may not have any idea they won't be notified anymore.
+     */
+    clear(): void;
+    /**
+     * Returns the number of active subscribers.
+     */
+    count(): number;
+    /**
+     * Pauses event delivery until unpaused. Any .notify() calls made while
+     * paused will get buffered into memory and emitted later.
+     */
+    pause(): void;
+    /**
+     * Emits all in-memory buffered events, and unpauses. Any .notify() calls
+     * made after this will be synchronously delivered again.
+     */
+    unpause(): void;
+    /**
+     * Observable instance, which can be used to subscribe to this event source
+     * in a readonly fashion. Safe to publicly expose.
+     */
+    observable: Observable<T>;
+};
+/**
+ * makeEventSource allows you to generate a subscribe/notify pair of functions
+ * to make subscribing easy and to get notified about events.
+ *
+ * The events are anonymous, so you can use it to define events, like so:
+ *
+ *   const event1 = makeEventSource();
+ *   const event2 = makeEventSource();
+ *
+ *   event1.subscribe(foo);
+ *   event1.subscribe(bar);
+ *   event2.subscribe(qux);
+ *
+ *   // Unsubscription is pretty standard
+ *   const unsub = event2.subscribe(foo);
+ *   unsub();
+ *
+ *   event1.notify();  // Now foo and bar will get called
+ *   event2.notify();  // Now qux will get called (but foo will not, since it's unsubscribed)
+ *
+ */
+declare function makeEventSource<T>(): EventSource<T>;
+
+interface IWebSocketEvent {
+    type: string;
+}
+interface IWebSocketCloseEvent extends IWebSocketEvent {
+    readonly code: WebsocketCloseCodes;
+    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;
+}
+/**
+ * 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.
+ */
+interface IWebSocket {
+    new (address: string): IWebSocketInstance;
+}
+/**
+ * The following ranges will be respected by the client:
+ *
+ *   10xx: client will reauthorize (just like 41xx)
+ *   40xx: client will disconnect
+ *   41xx: client will reauthorize
+ *   42xx: client will retry without reauthorizing (currently not used)
+ *
+ */
+declare enum WebsocketCloseCodes {
+    /** Normal close of connection, the connection fulfilled its purpose. */
+    CLOSE_NORMAL = 1000,
+    /** Unexpected error happened with the network/infra level. In spirit akin to HTTP 503 */
+    CLOSE_ABNORMAL = 1006,
+    /** Unexpected error happened. In spirit akin to HTTP 500 */
+    UNEXPECTED_CONDITION = 1011,
+    /** Please back off for now, but try again in a few moments */
+    TRY_AGAIN_LATER = 1013,
+    /** Message wasn't understood, disconnect */
+    INVALID_MESSAGE_FORMAT = 4000,
+    /** Server refused to allow connection. Re-authorizing won't help. Disconnect. In spirit akin to HTTP 403 */
+    NOT_ALLOWED = 4001,
+    /** Unused */
+    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
+    /** Unused */
+    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
+    /** Unused */
+    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
+    /** Room is full, disconnect */
+    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
+    /** The room's ID was updated, disconnect */
+    ROOM_ID_UPDATED = 4006,
+    /** The server kicked the connection from the room. */
+    KICKED = 4100,
+    /** The auth token is expired, reauthorize to get a fresh one. In spirit akin to HTTP 401 */
+    TOKEN_EXPIRED = 4109,
+    /** Disconnect immediately */
+    CLOSE_WITHOUT_RETRY = 4999
+}
+
+/**
+ * Returns a human-readable status indicating the current connection status of
+ * a Room, as returned by `room.getStatus()`. Can be used to implement
+ * a connection status badge.
+ */
+declare type Status = "initial" | "connecting" | "connected" | "reconnecting" | "disconnected";
+/**
+ * Used to report about app-level reconnection issues.
+ *
+ * Normal (quick) reconnects won't be reported as a "lost connection". Instead,
+ * the application will only get an event if the reconnection attempts by the
+ * client are taking (much) longer than usual. Definitely a situation you want
+ * to inform your users about, for example, by throwing a toast message on
+ * screen, or show a "trying to reconnect" banner.
+ */
+declare type LostConnectionEvent = "lost" | "restored" | "failed";
+/**
+ * Arbitrary record that will be used as the authentication "authValue". It's the
+ * value that is returned by calling the authentication delegate, and will get
+ * passed to the connection factory delegate. This value will be remembered by
+ * the connection manager, but its value will not be interpreted, so it can be
+ * any value (except null).
+ */
+declare type BaseAuthResult = NonNullable<Json>;
+declare class LiveblocksError extends Error {
+    code: number;
+}
+declare type Delegates<T extends BaseAuthResult> = {
+    authenticate: () => Promise<T>;
+    createSocket: (authValue: T) => IWebSocketInstance;
+    canZombie: () => boolean;
+};
+
 declare enum OpCode {
     INIT = 0,
     SET_PARENT_KEY = 1,
@@ -96,6 +320,25 @@ declare type AckOp = {
     readonly id: "ACK";
     readonly opId: string;
 };
+/**
+ * Create an Op that can be used as an acknowledgement for the given opId, to
+ * send back to the originating client in cases where the server decided to
+ * ignore the Op and not forward it.
+ *
+ * Why?
+ * It's important for the client to receive an acknowledgement for this, so
+ * that it can correctly update its own unacknowledged Ops administration.
+ * Otherwise it could get in "synchronizing" state indefinitely.
+ *
+ * CLEVER HACK
+ * Introducing a new Op type for this would not be backward-compatible as
+ * receiving such Op would crash old clients :(
+ * So the clever backward-compatible hack pulled here is that we codify the
+ * acknowledgement as a "deletion Op" for the non-existing node id "ACK". In
+ * old clients such Op is accepted, but will effectively be a no-op as that
+ * node does not exist, but as a side-effect the Op will get acknowledged.
+ */
+declare function ackOp(opId: string): AckOp;
 declare type SetParentKeyOp = {
     readonly opId?: string;
     readonly id: string;
@@ -184,56 +427,6 @@ declare type PlainLsonList = {
 };
 declare type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
 
-declare type LiveObjectUpdateDelta<O extends {
-    [key: string]: unknown;
-}> = {
-    [K in keyof O]?: UpdateDelta | undefined;
-};
-/**
- * A LiveObject notification that is sent in-client to any subscribers whenever
- * one or more of the entries inside the LiveObject instance have changed.
- */
-declare type LiveObjectUpdates<TData extends LsonObject> = {
-    type: "LiveObject";
-    node: LiveObject<TData>;
-    updates: LiveObjectUpdateDelta<TData>;
-};
-/**
- * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
- * Keys should be a string, and values should be serializable to JSON.
- * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
- */
-declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
-    constructor(obj?: O);
-    /**
-     * Transform the LiveObject into a javascript object
-     */
-    toObject(): O;
-    /**
-     * Adds or updates a property with a specified key and a value.
-     * @param key The key of the property to add
-     * @param value The value of the property to add
-     */
-    set<TKey extends keyof O>(key: TKey, value: O[TKey]): void;
-    /**
-     * Returns a specified property from the LiveObject.
-     * @param key The key of the property to get
-     */
-    get<TKey extends keyof O>(key: TKey): O[TKey];
-    /**
-     * Deletes a key from the LiveObject
-     * @param key The key of the property to delete
-     */
-    delete(key: keyof O): void;
-    /**
-     * Adds or updates multiple properties at once with an object.
-     * @param patch The object used to overrides properties
-     */
-    update(patch: Partial<O>): void;
-    toImmutable(): ToImmutable<O>;
-    clone(): LiveObject<O>;
-}
-
 /**
  * Helper type to convert any valid Lson type to the equivalent Json type.
  *
@@ -531,165 +724,73 @@ declare type ToJson<T extends Lson | LsonObject> = T extends Json ? T : T extend
     [K in KS]: ToJson<V>;
 } : never;
 
-/**
- * This helper type is effectively a no-op, but will force TypeScript to
- * "evaluate" any named helper types in its definition. This can sometimes make
- * API signatures clearer in IDEs.
- *
- * For example, in:
- *
- *   type Payload<T> = { data: T };
- *
- *   let r1: Payload<string>;
- *   let r2: Resolve<Payload<string>>;
- *
- * The inferred type of `r1` is going to be `Payload<string>` which shows up in
- * editor hints, and it may be unclear what's inside if you don't know the
- * definition of `Payload`.
- *
- * The inferred type of `r2` is going to be `{ data: string }`, which may be
- * more helpful.
- *
- * This trick comes from:
- * https://effectivetypescript.com/2022/02/25/gentips-4-display/
- */
-declare type Resolve<T> = T extends (...args: unknown[]) => unknown ? T : {
-    [K in keyof T]: T[K];
-};
-
-declare type CustomAuthenticationResult = {
-    token: string;
-    error?: never;
-} | {
-    token?: never;
-    error: "forbidden";
-    reason: string;
-} | {
-    token?: never;
-    error: string;
-    reason: string;
+declare type LiveObjectUpdateDelta<O extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof O]?: UpdateDelta | undefined;
 };
-
 /**
- * Represents some constraints for user info. Basically read this as: "any JSON
- * object is fine, but _if_ it has a name field, it _must_ be a string."
- * (Ditto for avatar.)
+ * A LiveObject notification that is sent in-client to any subscribers whenever
+ * one or more of the entries inside the LiveObject instance have changed.
  */
-declare type IUserInfo = {
-    [key: string]: Json | undefined;
-    name?: string;
-    avatar?: string;
+declare type LiveObjectUpdates<TData extends LsonObject> = {
+    type: "LiveObject";
+    node: LiveObject<TData>;
+    updates: LiveObjectUpdateDelta<TData>;
 };
 /**
- * This type is used by clients to define the metadata for a user.
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
  */
-declare type BaseUserMeta = {
+declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
+    constructor(obj?: O);
     /**
-     * The id of the user that has been set in the authentication endpoint.
-     * Useful to get additional information about the connected user.
+     * Transform the LiveObject into a javascript object
      */
-    id?: string;
+    toObject(): O;
     /**
-     * Additional user information that has been set in the authentication endpoint.
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
      */
-    info?: IUserInfo;
-};
-
-declare enum Permission {
-    Read = "room:read",
-    Write = "room:write",
-    PresenceWrite = "room:presence:write",
-    CommentsWrite = "comments:write",
-    CommentsRead = "comments:read"
-}
-declare type LiveblocksPermissions = Record<string, Permission[]>;
-declare enum TokenKind {
-    SECRET_LEGACY = "sec-legacy",
-    ACCESS_TOKEN = "acc",
-    ID_TOKEN = "id"
+    set<TKey extends keyof O>(key: TKey, value: O[TKey]): void;
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
+    get<TKey extends keyof O>(key: TKey): O[TKey];
+    /**
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
+     */
+    delete(key: keyof O): void;
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param patch The object used to overrides properties
+     */
+    update(patch: Partial<O>): void;
+    toImmutable(): ToImmutable<O>;
+    clone(): LiveObject<O>;
 }
-declare type JwtMeta = {
-    iat: number;
-    exp: number;
-};
-/**
- * Legacy Secret Token.
- */
-declare type LegacySecretToken = {
-    k: TokenKind.SECRET_LEGACY;
-    roomId: string;
-    scopes: string[];
-    id?: string;
-    info?: IUserInfo;
-    [other: string]: Json | undefined;
-} & JwtMeta;
-/**
- * New authorization Access Token.
- */
-declare type AccessToken = {
-    k: TokenKind.ACCESS_TOKEN;
-    pid: string;
-    uid: string;
-    perms: LiveblocksPermissions;
-    ui?: IUserInfo;
-} & JwtMeta;
-/**
- * New authorization ID Token.
- */
-declare type IDToken = {
-    k: TokenKind.ID_TOKEN;
-    pid: string;
-    uid: string;
-    gids?: string[];
-    ui?: IUserInfo;
-} & JwtMeta;
-declare type AuthToken = AccessToken | IDToken | LegacySecretToken;
-declare type ParsedAuthToken = {
-    readonly raw: string;
-    readonly parsed: AuthToken;
-};
-
-declare type AuthValue = {
-    type: "secret";
-    token: ParsedAuthToken;
-} | {
-    type: "public";
-    publicApiKey: string;
-};
 
-declare type BaseMetadata = Record<string, string | boolean | number>;
-
-declare type CommentBodyBlockElement = CommentBodyParagraph;
-declare type CommentBodyInlineElement = CommentBodyText | CommentBodyMention | CommentBodyLink;
-declare type CommentBodyElement = CommentBodyBlockElement | CommentBodyInlineElement;
-declare type CommentBodyParagraph = {
-    type: "paragraph";
-    children: CommentBodyInlineElement[];
-};
-declare type CommentBodyMention = {
-    type: "mention";
-    id: string;
-};
-declare type CommentBodyLink = {
-    type: "link";
-    url: string;
-};
-declare type CommentBodyText = {
-    bold?: boolean;
-    italic?: boolean;
-    strikethrough?: boolean;
-    code?: boolean;
-    text: string;
-};
-declare type CommentBody = {
-    version: 1;
-    content: CommentBodyBlockElement[];
+declare type BaseRoomInfo = {
+    [key: string]: Json | undefined;
+    /**
+     * The name of the room.
+     */
+    name?: string;
+    /**
+     * The URL of the room.
+     */
+    url?: string;
 };
 
 declare type DateToString<T> = {
-    [P in keyof T]: T[P] extends Date ? string : T[P];
+    [P in keyof T]: T[P] extends Date ? string : T[P] extends Date | null ? string | null : T[P] extends Date | undefined ? string | undefined : T[P];
 };
 
+declare type BaseMetadata = Record<string, string | boolean | number | undefined>;
 declare type CommentReaction = {
     emoji: string;
     createdAt: Date;
@@ -716,8 +817,8 @@ declare type CommentData = {
     body?: never;
     deletedAt: Date;
 });
-declare type CommentDataPlain = Omit<DateToString<CommentData>, "reaction" | "body"> & {
-    reactions: DateToString<CommentReaction[]>;
+declare type CommentDataPlain = Omit<DateToString<CommentData>, "reactions" | "body"> & {
+    reactions: DateToString<CommentReaction>[];
 } & ({
     body: CommentBody;
     deletedAt?: never;
@@ -725,265 +826,138 @@ declare type CommentDataPlain = Omit<DateToString<CommentData>, "reaction" | "bo
     body?: never;
     deletedAt: string;
 });
-
-declare type CommentUserReaction = {
-    emoji: string;
-    createdAt: Date;
-    userId: string;
+declare type CommentBodyBlockElement = CommentBodyParagraph;
+declare type CommentBodyInlineElement = CommentBodyText | CommentBodyMention | CommentBodyLink;
+declare type CommentBodyElement = CommentBodyBlockElement | CommentBodyInlineElement;
+declare type CommentBodyParagraph = {
+    type: "paragraph";
+    children: CommentBodyInlineElement[];
 };
-declare type CommentUserReactionPlain = DateToString<CommentUserReaction>;
-
-/**
- * Represents a thread of comments.
- */
-declare type ThreadData<TThreadMetadata extends BaseMetadata = never> = {
-    type: "thread";
+declare type CommentBodyMention = {
+    type: "mention";
     id: string;
-    roomId: string;
-    createdAt: Date;
-    updatedAt?: Date;
-    comments: CommentData[];
-    metadata: [TThreadMetadata] extends [never] ? Record<string, never> : TThreadMetadata;
-};
-declare type ThreadDataPlain<TThreadMetadata extends BaseMetadata = never> = Omit<DateToString<ThreadData<TThreadMetadata>>, "comments" | "metadata"> & {
-    comments: CommentDataPlain[];
-    metadata: [TThreadMetadata] extends [never] ? Record<string, never> : TThreadMetadata;
-};
-
-declare type Options = {
-    baseUrl: string;
-};
-declare type PartialNullable<T> = {
-    [P in keyof T]?: T[P] | null | undefined;
-};
-declare type ThreadsFilterOptions<TThreadMetadata extends BaseMetadata> = {
-    query?: {
-        metadata?: Partial<TThreadMetadata>;
-    };
-};
-declare type CommentsApi<TThreadMetadata extends BaseMetadata> = {
-    getThreads(options?: ThreadsFilterOptions<TThreadMetadata>): Promise<ThreadData<TThreadMetadata>[]>;
-    createThread(options: {
-        threadId: string;
-        commentId: string;
-        metadata: TThreadMetadata | undefined;
-        body: CommentBody;
-    }): Promise<ThreadData<TThreadMetadata>>;
-    editThreadMetadata(options: {
-        metadata: PartialNullable<TThreadMetadata>;
-        threadId: string;
-    }): Promise<TThreadMetadata>;
-    createComment(options: {
-        threadId: string;
-        commentId: string;
-        body: CommentBody;
-    }): Promise<CommentData>;
-    editComment(options: {
-        threadId: string;
-        commentId: string;
-        body: CommentBody;
-    }): Promise<CommentData>;
-    deleteComment(options: {
-        threadId: string;
-        commentId: string;
-    }): Promise<void>;
-    addReaction(options: {
-        threadId: string;
-        commentId: string;
-        emoji: string;
-    }): Promise<CommentUserReaction>;
-    removeReaction(options: {
-        threadId: string;
-        commentId: string;
-        emoji: string;
-    }): Promise<void>;
-};
-declare class CommentsApiError extends Error {
-    message: string;
-    status: number;
-    details?: JsonObject | undefined;
-    constructor(message: string, status: number, details?: JsonObject | undefined);
-}
-declare function createCommentsApi<TThreadMetadata extends BaseMetadata>(roomId: string, getAuthValue: () => Promise<AuthValue>, config: Options): CommentsApi<TThreadMetadata>;
-
-declare type Callback<T> = (event: T) => void;
-declare type UnsubscribeCallback = () => void;
-declare type Observable<T> = {
-    /**
-     * Register a callback function to be called whenever the event source emits
-     * an event.
-     */
-    subscribe(callback: Callback<T>): UnsubscribeCallback;
-    /**
-     * Register a one-time callback function to be called whenever the event
-     * source emits an event. After the event fires, the callback is
-     * auto-unsubscribed.
-     */
-    subscribeOnce(callback: Callback<T>): UnsubscribeCallback;
-    /**
-     * Returns a promise that will resolve when an event is emitted by this
-     * event source. Optionally, specify a predicate that has to match. The first
-     * event matching that predicate will then resolve the promise.
-     */
-    waitUntil(predicate?: (event: T) => boolean): Promise<T>;
 };
-declare type EventSource<T> = Observable<T> & {
-    /**
-     * Notify all subscribers about the event.
-     */
-    notify(event: T): void;
-    /**
-     * Clear all registered event listeners. None of the registered functions
-     * will ever get called again. Be careful when using this API, because the
-     * subscribers may not have any idea they won't be notified anymore.
-     */
-    clear(): void;
-    /**
-     * Returns the number of active subscribers.
-     */
-    count(): number;
-    /**
-     * Pauses event delivery until unpaused. Any .notify() calls made while
-     * paused will get buffered into memory and emitted later.
-     */
-    pause(): void;
-    /**
-     * Emits all in-memory buffered events, and unpauses. Any .notify() calls
-     * made after this will be synchronously delivered again.
-     */
-    unpause(): void;
-    /**
-     * Observable instance, which can be used to subscribe to this event source
-     * in a readonly fashion. Safe to publicly expose.
-     */
-    observable: Observable<T>;
+declare type CommentBodyLink = {
+    type: "link";
+    url: string;
+};
+declare type CommentBodyText = {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    code?: boolean;
+    text: string;
+};
+declare type CommentBody = {
+    version: 1;
+    content: CommentBodyBlockElement[];
+};
+declare type CommentUserReaction = {
+    emoji: string;
+    createdAt: Date;
+    userId: string;
 };
+declare type CommentUserReactionPlain = DateToString<CommentUserReaction>;
 /**
- * makeEventSource allows you to generate a subscribe/notify pair of functions
- * to make subscribing easy and to get notified about events.
- *
- * The events are anonymous, so you can use it to define events, like so:
- *
- *   const event1 = makeEventSource();
- *   const event2 = makeEventSource();
- *
- *   event1.subscribe(foo);
- *   event1.subscribe(bar);
- *   event2.subscribe(qux);
- *
- *   // Unsubscription is pretty standard
- *   const unsub = event2.subscribe(foo);
- *   unsub();
- *
- *   event1.notify();  // Now foo and bar will get called
- *   event2.notify();  // Now qux will get called (but foo will not, since it's unsubscribed)
- *
+ * Represents a thread of comments.
  */
-declare function makeEventSource<T>(): EventSource<T>;
-
-interface IWebSocketEvent {
-    type: string;
-}
-interface IWebSocketCloseEvent extends IWebSocketEvent {
-    readonly code: WebsocketCloseCodes;
-    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;
+declare type ThreadData<M extends BaseMetadata = DM> = {
+    type: "thread";
+    id: string;
+    roomId: string;
+    createdAt: Date;
+    updatedAt?: Date;
+    comments: CommentData[];
+    metadata: M;
+};
+interface ThreadDataWithDeleteInfo<M extends BaseMetadata = DM> extends ThreadData<M> {
+    deletedAt?: Date;
 }
+declare type ThreadDataPlain<M extends BaseMetadata> = Omit<DateToString<ThreadData<M>>, "comments" | "metadata"> & {
+    comments: CommentDataPlain[];
+    metadata: M;
+};
+declare type ThreadDeleteInfo = {
+    type: "deletedThread";
+    id: string;
+    roomId: string;
+    deletedAt: Date;
+};
+declare type QueryMetadataStringValue<T extends string> = T | {
+    startsWith: string;
+};
 /**
- * Either the browser-based WebSocket API or Node.js' WebSocket API (from the
- * 'ws' package).
+ * This type can be used to build a metadata query string (compatible
+ * with `@liveblocks/query-parser`) through a type-safe API.
  *
- * 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.
+ * In addition to exact values (`:` in query string), it adds:
+ * - to strings:
+ *  - `startsWith` (`^` in query string)
  */
-interface IWebSocket {
-    new (address: string): IWebSocketInstance;
+declare type QueryMetadata<M extends BaseMetadata> = {
+    [K in keyof M]: M[K] extends string ? QueryMetadataStringValue<M[K]> : M[K];
+};
+
+declare global {
+    /**
+     * Namespace for user-defined Liveblocks types.
+     */
+    export interface Liveblocks {
+        [key: string]: unknown;
+    }
 }
+declare type ExtendableTypes = "Presence" | "Storage" | "UserMeta" | "RoomEvent" | "ThreadMetadata" | "RoomInfo";
+declare type ExtendedType<K extends ExtendableTypes, B> = unknown extends Liveblocks[K] ? B : Liveblocks[K] extends B ? Liveblocks[K] : `The type you provided for '${K}' does not match its requirements. To learn how to fix this, see https://liveblocks.io/errors/${K}`;
+declare type DP = ExtendedType<"Presence", JsonObject>;
+declare type DS = ExtendedType<"Storage", LsonObject>;
+declare type DU = ExtendedType<"UserMeta", BaseUserMeta>;
+declare type DE = ExtendedType<"RoomEvent", Json>;
+declare type DM = ExtendedType<"ThreadMetadata", BaseMetadata>;
+declare type DRI = ExtendedType<"RoomInfo", BaseRoomInfo>;
+
 /**
- * The following ranges will be respected by the client:
- *
- *   40xx: client will disconnect
- *   41xx: client will reauthorize
- *   42xx: client will retry without reauthorizing (currently not used)
+ * Use this symbol to brand an object property as internal.
  *
+ * @example
+ * Object.defineProperty(
+ *   {
+ *     public,
+ *     [kInternal]: {
+ *       private
+ *     },
+ *   },
+ *   kInternal,
+ *   {
+ *     enumerable: false,
+ *   }
+ * );
  */
-declare enum WebsocketCloseCodes {
-    /** Unexpected error happened with the network/infra level. In spirit akin to HTTP 503 */
-    CLOSE_ABNORMAL = 1006,
-    /** Unexpected error happened. In spirit akin to HTTP 500 */
-    UNEXPECTED_CONDITION = 1011,
-    /** Please back off for now, but try again in a few moments */
-    TRY_AGAIN_LATER = 1013,
-    /** Message wasn't understood, disconnect */
-    INVALID_MESSAGE_FORMAT = 4000,
-    /** Server refused to allow connection. Re-authorizing won't help. Disconnect. In spirit akin to HTTP 403 */
-    NOT_ALLOWED = 4001,
-    /** Unused */
-    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
-    /** Unused */
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
-    /** Unused */
-    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
-    /** Room is full, disconnect */
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
-    /** The auth token is expired, reauthorize to get a fresh one. In spirit akin to HTTP 401 */
-    TOKEN_EXPIRED = 4109,
-    /** Disconnect immediately */
-    CLOSE_WITHOUT_RETRY = 4999
-}
+declare const kInternal: unique symbol;
 
 /**
- * Old connection statuses, here for backward-compatibility reasons only.
- */
-declare type LegacyConnectionStatus = "closed" | "authenticating" | "connecting" | "open" | "unavailable" | "failed";
-/**
- * Returns a human-readable status indicating the current connection status of
- * a Room, as returned by `room.getStatus()`. Can be used to implement
- * a connection status badge.
- */
-declare type Status = "initial" | "connecting" | "connected" | "reconnecting" | "disconnected";
-/**
- * Used to report about app-level reconnection issues.
+ * This helper type is effectively a no-op, but will force TypeScript to
+ * "evaluate" any named helper types in its definition. This can sometimes make
+ * API signatures clearer in IDEs.
  *
- * Normal (quick) reconnects won't be reported as a "lost connection". Instead,
- * the application will only get an event if the reconnection attempts by the
- * client are taking (much) longer than usual. Definitely a situation you want
- * to inform your users about, for example, by throwing a toast message on
- * screen, or show a "trying to reconnect" banner.
- */
-declare type LostConnectionEvent = "lost" | "restored" | "failed";
-/**
- * Arbitrary record that will be used as the authentication "authValue". It's the
- * value that is returned by calling the authentication delegate, and will get
- * passed to the connection factory delegate. This value will be remembered by
- * the connection manager, but its value will not be interpreted, so it can be
- * any value (except null).
+ * For example, in:
+ *
+ *   type Payload<T> = { data: T };
+ *
+ *   let r1: Payload<string>;
+ *   let r2: Resolve<Payload<string>>;
+ *
+ * The inferred type of `r1` is going to be `Payload<string>` which shows up in
+ * editor hints, and it may be unclear what's inside if you don't know the
+ * definition of `Payload`.
+ *
+ * The inferred type of `r2` is going to be `{ data: string }`, which may be
+ * more helpful.
+ *
+ * This trick comes from:
+ * https://effectivetypescript.com/2022/02/25/gentips-4-display/
  */
-declare type BaseAuthResult = NonNullable<Json>;
-declare type Delegates<T extends BaseAuthResult> = {
-    authenticate: () => Promise<T>;
-    createSocket: (authValue: T) => IWebSocketInstance;
-    canZombie: () => boolean;
+declare type Resolve<T> = T extends (...args: unknown[]) => unknown ? T : {
+    [K in keyof T]: T[K];
 };
 
 declare enum ClientMsgCode {
@@ -997,12 +971,12 @@ declare enum ClientMsgCode {
 /**
  * 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 | FetchYDocClientMsg | UpdateYDocClientMsg;
-declare type BroadcastEventClientMsg<TRoomEvent extends Json> = {
+declare type ClientMsg<P extends JsonObject, E extends Json> = BroadcastEventClientMsg<E> | UpdatePresenceClientMsg<P> | UpdateStorageClientMsg | FetchStorageClientMsg | FetchYDocClientMsg | UpdateYDocClientMsg;
+declare type BroadcastEventClientMsg<E extends Json> = {
     type: ClientMsgCode.BROADCAST_EVENT;
-    event: TRoomEvent;
+    event: E;
 };
-declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
+declare type UpdatePresenceClientMsg<P extends JsonObject> = {
     readonly type: ClientMsgCode.UPDATE_PRESENCE;
     /**
      * Set this to any number to signify that this is a Full Presence™
@@ -1018,7 +992,7 @@ declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
      * all presence fields, and isn't a partial "patch".
      */
     readonly targetActor: number;
-    readonly data: TPresence;
+    readonly data: P;
 } | {
     readonly type: ClientMsgCode.UPDATE_PRESENCE;
     /**
@@ -1026,7 +1000,7 @@ declare type UpdatePresenceClientMsg<TPresence extends JsonObject> = {
      * Presence™ "patch".
      */
     readonly targetActor?: undefined;
-    readonly data: Partial<TPresence>;
+    readonly data: Partial<P>;
 };
 declare type UpdateStorageClientMsg = {
     readonly type: ClientMsgCode.UPDATE_STORAGE;
@@ -1046,6 +1020,42 @@ declare type UpdateYDocClientMsg = {
     readonly guid?: string;
 };
 
+declare type InboxNotificationThreadData = {
+    kind: "thread";
+    id: string;
+    roomId: string;
+    threadId: string;
+    notifiedAt: Date;
+    readAt: Date | null;
+};
+declare type ActivityData = Record<string, string | boolean | number | undefined>;
+declare type InboxNotificationActivity = {
+    id: string;
+    createdAt: Date;
+    data: ActivityData;
+};
+declare type InboxNotificationCustomData = {
+    kind: `$${string}`;
+    id: string;
+    roomId?: string;
+    subjectId: string;
+    notifiedAt: Date;
+    readAt: Date | null;
+    activities: InboxNotificationActivity[];
+};
+declare type InboxNotificationData = InboxNotificationThreadData | InboxNotificationCustomData;
+declare type InboxNotificationThreadDataPlain = DateToString<InboxNotificationThreadData>;
+declare type InboxNotificationCustomDataPlain = Omit<DateToString<InboxNotificationCustomData>, "activities"> & {
+    activities: DateToString<InboxNotificationActivity>[];
+};
+declare type InboxNotificationDataPlain = InboxNotificationThreadDataPlain | InboxNotificationCustomDataPlain;
+declare type InboxNotificationDeleteInfo = {
+    type: "deletedInboxNotification";
+    id: string;
+    roomId: string;
+    deletedAt: Date;
+};
+
 declare type IdTuple<T> = [id: string, value: T];
 declare enum CrdtType {
     OBJECT = 0,
@@ -1107,7 +1117,7 @@ declare enum ServerMsgCode {
 /**
  * Messages that can be sent from the server to the client.
  */
-declare type ServerMsg<TPresence extends JsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = UpdatePresenceServerMsg<TPresence> | UserJoinServerMsg<TUserMeta> | UserLeftServerMsg | BroadcastedEventServerMsg<TRoomEvent> | RoomStateServerMsg<TUserMeta> | InitialDocumentStateServerMsg | UpdateStorageServerMsg | RejectedStorageOpServerMsg | YDocUpdateServerMsg | CommentsEventServerMsg;
+declare type ServerMsg<P extends JsonObject, U extends BaseUserMeta, E extends Json> = UpdatePresenceServerMsg<P> | UserJoinServerMsg<U> | UserLeftServerMsg | BroadcastedEventServerMsg<E> | RoomStateServerMsg<U> | InitialDocumentStateServerMsg | UpdateStorageServerMsg | RejectedStorageOpServerMsg | YDocUpdateServerMsg | CommentsEventServerMsg;
 declare type CommentsEventServerMsg = ThreadCreatedEvent | ThreadMetadataUpdatedEvent | CommentCreatedEvent | CommentEditedEvent | CommentDeletedEvent | CommentReactionAdded | CommentReactionRemoved;
 declare type ThreadCreatedEvent = {
     type: ServerMsgCode.THREAD_CREATED;
@@ -1155,7 +1165,7 @@ declare type CommentReactionRemoved = {
  * those cases, the `targetActor` field indicates the newly connected client,
  * so all other existing clients can ignore this broadcasted message.
  */
-declare type UpdatePresenceServerMsg<TPresence extends JsonObject> = {
+declare type UpdatePresenceServerMsg<P extends JsonObject> = {
     readonly type: ServerMsgCode.UPDATE_PRESENCE;
     /**
      * The User whose Presence has changed.
@@ -1179,7 +1189,7 @@ declare type UpdatePresenceServerMsg<TPresence extends JsonObject> = {
      * this will be the full Presence, otherwise it only contain the fields that
      * have changed since the last broadcast.
      */
-    readonly data: TPresence;
+    readonly data: P;
 } | {
     readonly type: ServerMsgCode.UPDATE_PRESENCE;
     /**
@@ -1194,25 +1204,25 @@ declare type UpdatePresenceServerMsg<TPresence extends JsonObject> = {
      * A partial Presence patch to apply to the User. It will only contain the
      * fields that have changed since the last broadcast.
      */
-    readonly data: Partial<TPresence>;
+    readonly data: Partial<P>;
 };
 /**
  * Sent by the WebSocket server and broadcasted to all clients to announce that
  * a new User has joined the Room.
  */
-declare type UserJoinServerMsg<TUserMeta extends BaseUserMeta> = {
+declare type UserJoinServerMsg<U extends BaseUserMeta> = {
     readonly type: ServerMsgCode.USER_JOINED;
     readonly actor: number;
     /**
      * The id of the User that has been set in the authentication endpoint.
      * Useful to get additional information about the connected user.
      */
-    readonly id: TUserMeta["id"];
+    readonly id: U["id"];
     /**
      * Additional user information that has been set in the authentication
      * endpoint.
      */
-    readonly info: TUserMeta["info"];
+    readonly info: U["info"];
     /**
      * Informs the client what (public) permissions this (other) User has.
      */
@@ -1241,7 +1251,7 @@ declare type YDocUpdateServerMsg = {
  * Sent by the WebSocket server and broadcasted to all clients to announce that
  * a User broadcasted an Event to everyone in the Room.
  */
-declare type BroadcastedEventServerMsg<TRoomEvent extends Json> = {
+declare type BroadcastedEventServerMsg<E extends Json> = {
     readonly type: ServerMsgCode.BROADCASTED_EVENT;
     /**
      * The User who broadcast the Event. Absent when this event is broadcast from
@@ -1252,14 +1262,14 @@ declare type BroadcastedEventServerMsg<TRoomEvent extends Json> = {
      * The arbitrary payload of the Event. This can be any JSON value. Clients
      * will have to manually verify/decode this event.
      */
-    readonly event: TRoomEvent;
+    readonly event: E;
 };
 /**
  * Sent by the WebSocket server to a single client in response to the client
  * joining the Room, to provide the initial state of the Room. The payload
  * includes a list of all other Users that already are in the Room.
  */
-declare type RoomStateServerMsg<TUserMeta extends BaseUserMeta> = {
+declare type RoomStateServerMsg<U extends BaseUserMeta> = {
     readonly type: ServerMsgCode.ROOM_STATE;
     /**
      * Informs the client what their actor ID is going to be.
@@ -1277,7 +1287,7 @@ declare type RoomStateServerMsg<TUserMeta extends BaseUserMeta> = {
      */
     readonly scopes: string[];
     readonly users: {
-        readonly [otherActor: number]: TUserMeta & {
+        readonly [otherActor: number]: U & {
             scopes: string[];
         };
     };
@@ -1313,10 +1323,54 @@ declare type RejectedStorageOpServerMsg = {
     readonly reason: string;
 };
 
+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 CustomEventTreeNode = {
+    readonly type: "CustomEvent";
+    readonly id: string;
+    readonly key: string;
+    readonly connectionId: number;
+    readonly payload: Json;
+};
+declare type TreeNode = LsonTreeNode | UserTreeNode | CustomEventTreeNode;
+
+type DevToolsTreeNode_CustomEventTreeNode = CustomEventTreeNode;
+type DevToolsTreeNode_JsonTreeNode = JsonTreeNode;
+type DevToolsTreeNode_LiveTreeNode<TName extends `Live${string}` = `Live${string}`> = LiveTreeNode<TName>;
+type DevToolsTreeNode_LsonTreeNode = LsonTreeNode;
+type DevToolsTreeNode_TreeNode = TreeNode;
+type DevToolsTreeNode_UserTreeNode = UserTreeNode;
+declare namespace DevToolsTreeNode {
+  export type { DevToolsTreeNode_CustomEventTreeNode as CustomEventTreeNode, DevToolsTreeNode_JsonTreeNode as JsonTreeNode, DevToolsTreeNode_LiveTreeNode as LiveTreeNode, DevToolsTreeNode_LsonTreeNode as LsonTreeNode, DevToolsTreeNode_TreeNode as TreeNode, DevToolsTreeNode_UserTreeNode as UserTreeNode };
+}
+
 /**
  * Represents a user connected in a room. Treated as immutable.
  */
-declare type User<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
+declare type User<P extends JsonObject = DP, U extends BaseUserMeta = DU> = {
     /**
      * The connection ID of the User. It is unique and increment at every new connection.
      */
@@ -1325,21 +1379,15 @@ declare type User<TPresence extends JsonObject, TUserMeta extends BaseUserMeta>
      * The ID of the User that has been set in the authentication endpoint.
      * Useful to get additional information about the connected user.
      */
-    readonly id: TUserMeta["id"];
+    readonly id: U["id"];
     /**
      * Additional user information that has been set in the authentication endpoint.
      */
-    readonly info: TUserMeta["info"];
+    readonly info: U["info"];
     /**
      * The user’s presence data.
      */
-    readonly presence: TPresence;
-    /**
-     * @deprecated Use `!user.canWrite` instead.
-     * False if the user can mutate the Room’s Storage and/or YDoc, true if they
-     * can only read but not mutate it.
-     */
-    readonly isReadOnly: boolean;
+    readonly presence: P;
     /**
      * True if the user can mutate the Room’s Storage and/or YDoc, false if they
      * can only read but not mutate it.
@@ -1351,42 +1399,48 @@ declare type User<TPresence extends JsonObject, TUserMeta extends BaseUserMeta>
     readonly canComment: boolean;
 };
 
-/**
- * @deprecated Use `readonly User<TPresence, TUserMeta>[]` instead of `Others<TPresence, TUserMeta>`.
- */
-declare type Others<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = readonly User<TPresence, TUserMeta>[];
-declare type InternalOthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
+declare type InternalOthersEvent<P extends JsonObject, U extends BaseUserMeta> = {
     type: "leave";
-    user: User<TPresence, TUserMeta>;
+    user: User<P, U>;
 } | {
     type: "enter";
-    user: User<TPresence, TUserMeta>;
+    user: User<P, U>;
 } | {
     type: "update";
-    user: User<TPresence, TUserMeta>;
-    updates: Partial<TPresence>;
+    user: User<P, U>;
+    updates: Partial<P>;
 } | {
     type: "reset";
+    user?: never;
 };
-declare type OthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = Resolve<InternalOthersEvent<TPresence, TUserMeta> & {
-    others: readonly User<TPresence, TUserMeta>[];
+declare type OthersEvent<P extends JsonObject = DP, U extends BaseUserMeta = DU> = Resolve<InternalOthersEvent<P, U> & {
+    others: readonly User<P, U>[];
 }>;
 
-declare type LegacyOthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
+declare type PartialNullable<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+
+declare type RoomThreadsNotificationSettings = "all" | "replies_and_mentions" | "none";
+declare type RoomNotificationSettings = {
+    threads: RoomThreadsNotificationSettings;
+};
+
+declare type LegacyOthersEvent<P extends JsonObject, U extends BaseUserMeta> = {
     type: "leave";
-    user: User<TPresence, TUserMeta>;
+    user: User<P, U>;
 } | {
     type: "enter";
-    user: User<TPresence, TUserMeta>;
+    user: User<P, U>;
 } | {
     type: "update";
-    user: User<TPresence, TUserMeta>;
-    updates: Partial<TPresence>;
+    user: User<P, U>;
+    updates: Partial<P>;
 } | {
     type: "reset";
 };
-declare type LegacyOthersEventCallback<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = (others: readonly User<TPresence, TUserMeta>[], event: LegacyOthersEvent<TPresence, TUserMeta>) => void;
-declare type RoomEventMessage<TPresence extends JsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = {
+declare type LegacyOthersEventCallback<P extends JsonObject, U extends BaseUserMeta> = (others: readonly User<P, U>[], event: LegacyOthersEvent<P, U>) => void;
+declare type RoomEventMessage<P extends JsonObject, U extends BaseUserMeta, E extends Json> = {
     /**
      * The connection ID of the client that sent the event.
      * If this message was broadcast from the server (via the REST API), then
@@ -1398,8 +1452,8 @@ declare type RoomEventMessage<TPresence extends JsonObject, TUserMeta extends Ba
      * If this message was broadcast from the server (via the REST API), then
      * this value will be null.
      */
-    user: User<TPresence, TUserMeta> | null;
-    event: TRoomEvent;
+    user: User<P, U> | null;
+    event: E;
 };
 declare type StorageStatus = "not-loaded" | "loading" | "synchronizing" | "synchronized";
 interface History {
@@ -1491,7 +1545,7 @@ declare type BroadcastOptions = {
      */
     shouldQueueEventIfNotReady: boolean;
 };
-declare type SubscribeFn<TPresence extends JsonObject, _TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = {
+declare type SubscribeFn<P extends JsonObject, _TStorage extends LsonObject, U extends BaseUserMeta, E extends Json> = {
     /**
      * Subscribe to the current user presence updates.
      *
@@ -1504,7 +1558,7 @@ declare type SubscribeFn<TPresence extends JsonObject, _TStorage extends LsonObj
      *   // Do something
      * });
      */
-    (type: "my-presence", listener: Callback<TPresence>): () => void;
+    (type: "my-presence", listener: Callback<P>): () => void;
     /**
      * Subscribe to the other users updates.
      *
@@ -1518,52 +1572,28 @@ declare type SubscribeFn<TPresence extends JsonObject, _TStorage extends LsonObj
      * });
      *
      */
-    (type: "others", listener: LegacyOthersEventCallback<TPresence, TUserMeta>): () => void;
+    (type: "others", listener: LegacyOthersEventCallback<P, U>): () => 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<RoomEventMessage<TPresence, TUserMeta, TRoomEvent>>): () => void;
-    /**
-     * Subscribe to errors thrown in the room.
-     *
-     * @returns Unsubscribe function.
-     *
-     */
-    (type: "error", listener: ErrorCallback): () => void;
-    /**
-     * @deprecated This API will be removed in a future version of Liveblocks.
-     * Prefer using the newer `.subscribe('status')` API.
-     *
-     * We recommend making the following changes if you use these APIs:
-     *
-     *     OLD APIs                       NEW APIs
-     *     .getConnectionState()     -->  .getStatus()
-     *     .subscribe('connection')  -->  .subscribe('status')
+     * @returns Unsubscribe function.
      *
-     *     OLD STATUSES         NEW STATUSES
-     *     closed          -->  initial
-     *     authenticating  -->  connecting
-     *     connecting      -->  connecting
-     *     open            -->  connected
-     *     unavailable     -->  reconnecting
-     *     failed          -->  disconnected
+     * @example
+     * room.subscribe("event", ({ event, connectionId }) => {
+     *   // Do something
+     * });
      *
-     * Subscribe to legacy connection status updates.
+     */
+    (type: "event", listener: Callback<RoomEventMessage<P, U, E>>): () => void;
+    /**
+     * Subscribe to errors thrown in the room.
      *
      * @returns Unsubscribe function.
      *
      */
-    (type: "connection", listener: Callback<LegacyConnectionStatus>): () => void;
+    (type: "error", listener: Callback<LiveblocksError>): () => void;
     /**
      * Subscribe to connection status updates. The callback will be called any
      * time the status changes.
@@ -1648,36 +1678,88 @@ declare type SubscribeFn<TPresence extends JsonObject, _TStorage extends LsonObj
      */
     (type: "storage-status", listener: Callback<StorageStatus>): () => void;
 };
-declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = CommentsApi<any> & {
+declare type GetThreadsOptions<M extends BaseMetadata> = {
+    query?: {
+        metadata?: Partial<QueryMetadata<M>>;
+    };
+    since?: Date;
+};
+declare type CommentsApi<M extends BaseMetadata> = {
+    getThreads(options?: GetThreadsOptions<M>): Promise<{
+        threads: ThreadData<M>[];
+        inboxNotifications: InboxNotificationData[];
+        deletedThreads: ThreadDeleteInfo[];
+        deletedInboxNotifications: InboxNotificationDeleteInfo[];
+        meta: {
+            requestedAt: Date;
+        };
+    }>;
+    getThread(options: {
+        threadId: string;
+    }): Promise<{
+        thread: ThreadData<M>;
+        inboxNotification?: InboxNotificationData;
+    } | undefined>;
+    createThread(options: {
+        threadId: string;
+        commentId: string;
+        metadata: M | undefined;
+        body: CommentBody;
+    }): Promise<ThreadData<M>>;
+    editThreadMetadata(options: {
+        metadata: PartialNullable<M>;
+        threadId: string;
+    }): Promise<M>;
+    createComment(options: {
+        threadId: string;
+        commentId: string;
+        body: CommentBody;
+    }): Promise<CommentData>;
+    editComment(options: {
+        threadId: string;
+        commentId: string;
+        body: CommentBody;
+    }): Promise<CommentData>;
+    deleteComment(options: {
+        threadId: string;
+        commentId: string;
+    }): Promise<void>;
+    addReaction(options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }): Promise<CommentUserReaction>;
+    removeReaction(options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }): Promise<void>;
+};
+/**
+ * @private Widest-possible Room type, matching _any_ Room instance. Note that
+ * this type is different from `Room`-without-type-arguments. That represents
+ * a Room instance using globally augmented types only, which is narrower.
+ */
+declare type OpaqueRoom = Room<JsonObject, LsonObject, BaseUserMeta, Json, BaseMetadata>;
+declare type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extends BaseUserMeta = DU, E extends Json = DE, M extends BaseMetadata = DM> = {
     /**
-     * The id of the room.
+     * @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 id: string;
+    readonly [kInternal]: PrivateRoomApi<M>;
     /**
-     * @deprecated This API will be removed in a future version of Liveblocks.
-     * Prefer using `.getStatus()` instead.
-     *
-     * We recommend making the following changes if you use these APIs:
-     *
-     *     OLD APIs                       NEW APIs
-     *     .getConnectionState()     -->  .getStatus()
-     *     .subscribe('connection')  -->  .subscribe('status')
-     *
-     *     OLD STATUSES         NEW STATUSES
-     *     closed          -->  initial
-     *     authenticating  -->  connecting
-     *     connecting      -->  connecting
-     *     open            -->  connected
-     *     unavailable     -->  reconnecting
-     *     failed          -->  disconnected
+     * The id of the room.
      */
-    getConnectionState(): LegacyConnectionStatus;
+    readonly id: string;
     /**
      * Return the current connection status for this room. Can be used to display
      * a status badge for your Liveblocks connection.
      */
     getStatus(): Status;
-    readonly subscribe: SubscribeFn<TPresence, TStorage, TUserMeta, TRoomEvent>;
+    readonly subscribe: SubscribeFn<P, S, U, E>;
     /**
      * Room's history contains functions that let you undo and redo operation made on by the current client on the presence and storage.
      */
@@ -1689,21 +1771,21 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      * @example
      * const user = room.getSelf();
      */
-    getSelf(): User<TPresence, TUserMeta> | null;
+    getSelf(): User<P, U> | null;
     /**
      * Gets the presence of the current user.
      *
      * @example
      * const presence = room.getPresence();
      */
-    getPresence(): TPresence;
+    getPresence(): P;
     /**
      * Gets all the other users in the room.
      *
      * @example
      * const others = room.getOthers();
      */
-    getOthers(): readonly User<TPresence, TUserMeta>[];
+    getOthers(): readonly User<P, U>[];
     /**
      * Updates the presence of the current user. Only pass the properties you want to update. No need to send the full presence.
      * @param patch A partial object that contains the properties you want to update.
@@ -1716,15 +1798,14 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      * const presence = room.getPresence();
      * // presence is equivalent to { x: 0, y: 0 }
      */
-    updatePresence(patch: Partial<TPresence>, options?: {
+    updatePresence(patch: Partial<P>, options?: {
         /**
          * Whether or not the presence should have an impact on the undo/redo history.
          */
         addToHistory: boolean;
     }): void;
     /**
-     *
-     * Sends Yjs document updates to liveblocks server
+     * Sends Yjs document updates to Liveblocks server.
      *
      * @param {string} data the doc update to send to the server, base64 encoded uint8array
      */
@@ -1748,7 +1829,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      *   }
      * });
      */
-    broadcastEvent(event: TRoomEvent, options?: BroadcastOptions): void;
+    broadcastEvent(event: E, options?: BroadcastOptions): void;
     /**
      * Get the room's storage asynchronously.
      * The storage's root is a {@link LiveObject}.
@@ -1757,7 +1838,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      * const { root } = await room.getStorage();
      */
     getStorage(): Promise<{
-        root: LiveObject<TStorage>;
+        root: LiveObject<S>;
     }>;
     /**
      * Get the room's storage synchronously.
@@ -1766,15 +1847,15 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      * @example
      * const root = room.getStorageSnapshot();
      */
-    getStorageSnapshot(): LiveObject<TStorage> | null;
+    getStorageSnapshot(): LiveObject<S> | null;
     readonly events: {
         readonly status: Observable<Status>;
         readonly lostConnection: Observable<LostConnectionEvent>;
-        readonly customEvent: Observable<RoomEventMessage<TPresence, TUserMeta, TRoomEvent>>;
-        readonly self: Observable<User<TPresence, TUserMeta>>;
-        readonly myPresence: Observable<TPresence>;
-        readonly others: Observable<OthersEvent<TPresence, TUserMeta>>;
-        readonly error: Observable<Error>;
+        readonly customEvent: Observable<RoomEventMessage<P, U, E>>;
+        readonly self: Observable<User<P, U>>;
+        readonly myPresence: Observable<P>;
+        readonly others: Observable<OthersEvent<P, U>>;
+        readonly error: Observable<LiveblocksError>;
         readonly storage: Observable<StorageUpdate[]>;
         readonly history: Observable<HistoryEvent>;
         /**
@@ -1834,21 +1915,50 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
      */
     reconnect(): void;
 };
+/**
+ * @private
+ *
+ * Private methods to directly control the underlying state machine for this
+ * room. Used in the core internals and for unit testing, but as a user of
+ * Liveblocks, NEVER USE ANY OF THESE METHODS DIRECTLY, because bad things
+ * will probably happen if you do.
+ */
+declare type PrivateRoomApi<M extends BaseMetadata> = {
+    presenceBuffer: Json | undefined;
+    undoStack: readonly (readonly Readonly<HistoryOp<JsonObject>>[])[];
+    nodeCount: number;
+    getSelf_forDevTools(): UserTreeNode | null;
+    getOthers_forDevTools(): readonly UserTreeNode[];
+    simulate: {
+        explicitClose(event: IWebSocketCloseEvent): void;
+        rawSend(data: string): void;
+    };
+    comments: CommentsApi<M>;
+    notifications: {
+        getRoomNotificationSettings(): Promise<RoomNotificationSettings>;
+        updateRoomNotificationSettings(settings: Partial<RoomNotificationSettings>): Promise<RoomNotificationSettings>;
+        markInboxNotificationAsRead(notificationId: string): Promise<void>;
+    };
+};
+declare type HistoryOp<P extends JsonObject> = Op | {
+    readonly type: "presence";
+    readonly data: P;
+};
 declare type Polyfills = {
     atob?: (data: string) => string;
     fetch?: typeof fetch;
     WebSocket?: IWebSocket;
 };
-declare type RoomInitializers<TPresence extends JsonObject, TStorage extends LsonObject> = Resolve<{
+declare type RoomInitializers<P extends JsonObject, S extends LsonObject> = Resolve<{
     /**
      * The initial Presence to use and announce when you enter the Room. The
      * Presence is available on all users in the Room (me & others).
      */
-    initialPresence: TPresence | ((roomId: string) => TPresence);
+    initialPresence: P | ((roomId: string) => P);
     /**
      * The initial Storage to use when entering a new Room.
      */
-    initialStorage?: TStorage | ((roomId: string) => TStorage);
+    initialStorage?: S | ((roomId: string) => S);
     /**
      * Whether or not the room automatically connects to Liveblock servers.
      * Default is true.
@@ -1857,11 +1967,178 @@ declare type RoomInitializers<TPresence extends JsonObject, TStorage extends Lso
      * the authentication endpoint or connect via WebSocket.
      */
     autoConnect?: boolean;
-    /** @deprecated Renamed to `autoConnect` */
-    shouldInitiallyConnect?: boolean;
 }>;
+declare class CommentsApiError extends Error {
+    message: string;
+    status: number;
+    details?: JsonObject | undefined;
+    constructor(message: string, status: number, details?: JsonObject | undefined);
+}
+
+declare type BatchStoreStateLoading = {
+    isLoading: true;
+    data?: never;
+    error?: never;
+};
+declare type BatchStoreStateError = {
+    isLoading: false;
+    data?: never;
+    error: Error;
+};
+declare type BatchStoreStateSuccess<T> = {
+    isLoading: false;
+    data: T;
+    error?: never;
+};
+declare type BatchStoreState<T> = BatchStoreStateLoading | BatchStoreStateError | BatchStoreStateSuccess<T>;
+declare type BatchStore<T, A extends unknown[]> = EventSource<BatchStoreState<T> | undefined> & {
+    get: (...args: A) => Promise<void>;
+    getState: (...args: A) => BatchStoreState<T> | undefined;
+};
+
+declare type Store<T> = {
+    get: () => T;
+    set: (callback: (currentState: T) => T) => void;
+    subscribe: (callback: (state: T) => void) => () => void;
+};
+
+declare type GetInboxNotificationsOptions = {
+    limit?: number;
+    since?: Date;
+};
+
+declare type OptimisticUpdate<M extends BaseMetadata> = CreateThreadOptimisticUpdate<M> | EditThreadMetadataOptimisticUpdate<M> | CreateCommentOptimisticUpdate | EditCommentOptimisticUpdate | DeleteCommentOptimisticUpdate | AddReactionOptimisticUpdate | RemoveReactionOptimisticUpdate | MarkInboxNotificationAsReadOptimisticUpdate | MarkAllInboxNotificationsAsReadOptimisticUpdate | UpdateNotificationSettingsOptimisticUpdate;
+declare type CreateThreadOptimisticUpdate<M extends BaseMetadata> = {
+    type: "create-thread";
+    id: string;
+    thread: ThreadData<M>;
+};
+declare type EditThreadMetadataOptimisticUpdate<M extends BaseMetadata> = {
+    type: "edit-thread-metadata";
+    id: string;
+    threadId: string;
+    metadata: Resolve<PartialNullable<M>>;
+    updatedAt: Date;
+};
+declare type CreateCommentOptimisticUpdate = {
+    type: "create-comment";
+    id: string;
+    comment: CommentData;
+};
+declare type EditCommentOptimisticUpdate = {
+    type: "edit-comment";
+    id: string;
+    comment: CommentData;
+};
+declare type DeleteCommentOptimisticUpdate = {
+    type: "delete-comment";
+    id: string;
+    threadId: string;
+    deletedAt: Date;
+    commentId: string;
+};
+declare type AddReactionOptimisticUpdate = {
+    type: "add-reaction";
+    id: string;
+    threadId: string;
+    commentId: string;
+    reaction: CommentUserReaction;
+};
+declare type RemoveReactionOptimisticUpdate = {
+    type: "remove-reaction";
+    id: string;
+    threadId: string;
+    commentId: string;
+    emoji: string;
+    userId: string;
+    removedAt: Date;
+};
+declare type MarkInboxNotificationAsReadOptimisticUpdate = {
+    type: "mark-inbox-notification-as-read";
+    id: string;
+    inboxNotificationId: string;
+    readAt: Date;
+};
+declare type MarkAllInboxNotificationsAsReadOptimisticUpdate = {
+    type: "mark-inbox-notifications-as-read";
+    id: string;
+    readAt: Date;
+};
+declare type UpdateNotificationSettingsOptimisticUpdate = {
+    type: "update-notification-settings";
+    id: string;
+    roomId: string;
+    settings: Partial<RoomNotificationSettings>;
+};
+declare type QueryState = {
+    isLoading: true;
+    error?: never;
+} | {
+    isLoading: false;
+    error?: Error;
+};
+declare type CacheState<M extends BaseMetadata> = {
+    /**
+     * Threads by ID.
+     */
+    threads: Record<string, ThreadDataWithDeleteInfo<M>>;
+    /**
+     * Keep track of loading and error status of all the queries made by the client.
+     */
+    queries: Record<string, QueryState>;
+    /**
+     * Optimistic updates that have not been acknowledged by the server yet.
+     * They are applied on top of the threads in selectors.
+     */
+    optimisticUpdates: OptimisticUpdate<M>[];
+    /**
+     * Inbox notifications by ID.
+     */
+    inboxNotifications: Record<string, InboxNotificationData>;
+    /**
+     * Notification settings per room id
+     */
+    notificationSettings: Record<string, RoomNotificationSettings>;
+};
+interface CacheStore<M extends BaseMetadata> extends Store<CacheState<M>> {
+    deleteThread(threadId: string): void;
+    updateThreadAndNotification(thread: ThreadData<M>, inboxNotification?: InboxNotificationData): void;
+    updateThreadsAndNotifications(threads: ThreadData<M>[], inboxNotifications: InboxNotificationData[], deletedThreads: ThreadDeleteInfo[], deletedInboxNotifications: InboxNotificationDeleteInfo[], queryKey?: string): void;
+    updateRoomInboxNotificationSettings(roomId: string, settings: RoomNotificationSettings, queryKey: string): void;
+    pushOptimisticUpdate(optimisticUpdate: OptimisticUpdate<M>): void;
+    setQueryState(queryKey: string, queryState: QueryState): void;
+}
+declare function applyOptimisticUpdates<M extends BaseMetadata>(state: CacheState<M>): Pick<CacheState<M>, "threads" | "inboxNotifications" | "notificationSettings">;
+declare function upsertComment<M extends BaseMetadata>(thread: ThreadDataWithDeleteInfo<M>, comment: CommentData): ThreadDataWithDeleteInfo<M>;
+declare function deleteComment<M extends BaseMetadata>(thread: ThreadDataWithDeleteInfo<M>, commentId: string, deletedAt: Date): ThreadDataWithDeleteInfo<M>;
+declare function addReaction<M extends BaseMetadata>(thread: ThreadDataWithDeleteInfo<M>, commentId: string, reaction: CommentUserReaction): ThreadDataWithDeleteInfo<M>;
+declare function removeReaction<M extends BaseMetadata>(thread: ThreadDataWithDeleteInfo<M>, commentId: string, emoji: string, userId: string, removedAt: Date): ThreadDataWithDeleteInfo<M>;
 
-declare type EnterOptions<TPresence extends JsonObject, TStorage extends LsonObject> = Resolve<RoomInitializers<TPresence, TStorage> & {
+declare type OptionalPromise<T> = T | Promise<T>;
+
+declare type ResolveMentionSuggestionsArgs = {
+    /**
+     * The ID of the current room.
+     */
+    roomId: string;
+    /**
+     * The text to search for.
+     */
+    text: string;
+};
+declare type ResolveUsersArgs = {
+    /**
+     * The IDs of the users to resolve.
+     */
+    userIds: string[];
+};
+declare type ResolveRoomsInfoArgs = {
+    /**
+     * The IDs of the rooms to resolve.
+     */
+    roomIds: string[];
+};
+declare type EnterOptions<P extends JsonObject = DP, S extends LsonObject = DS> = Resolve<RoomInitializers<P, S> & {
     /**
      * Only necessary when you’re using Liveblocks with React v17 or lower.
      *
@@ -1872,44 +2149,60 @@ declare type EnterOptions<TPresence extends JsonObject, TStorage extends LsonObj
      */
     unstable_batchedUpdates?: (cb: () => void) => void;
 }>;
-declare type Client = {
+/**
+ * @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.
+ */
+declare type PrivateClientApi<U extends BaseUserMeta, M extends BaseMetadata> = {
+    readonly notifications: NotificationsApi<M>;
+    readonly currentUserIdStore: Store<string | null>;
+    readonly resolveMentionSuggestions: ClientOptions<U>["resolveMentionSuggestions"];
+    readonly cacheStore: CacheStore<BaseMetadata>;
+    readonly usersStore: BatchStore<U["info"] | undefined, [string]>;
+    readonly roomsInfoStore: BatchStore<DRI | undefined, [string]>;
+    readonly getRoomIds: () => string[];
+};
+declare type NotificationsApi<M extends BaseMetadata> = {
+    getInboxNotifications(options?: GetInboxNotificationsOptions): Promise<{
+        inboxNotifications: InboxNotificationData[];
+        threads: ThreadData<M>[];
+        deletedThreads: ThreadDeleteInfo[];
+        deletedInboxNotifications: InboxNotificationDeleteInfo[];
+        meta: {
+            requestedAt: Date;
+        };
+    }>;
+    getUnreadInboxNotificationsCount(): Promise<number>;
+    markAllInboxNotificationsAsRead(): Promise<void>;
+    markInboxNotificationAsRead(inboxNotificationId: string): Promise<void>;
+};
+/**
+ * @private Widest-possible Client type, matching _any_ Client instance. Note
+ * that this type is different from `Client`-without-type-arguments. That
+ * represents a Client instance using globally augmented types only, which is
+ * narrower.
+ */
+declare type OpaqueClient = Client<BaseUserMeta>;
+declare type Client<U extends BaseUserMeta = DU> = {
     /**
      * Gets a room. Returns null if {@link Client.enter} has not been called previously.
      *
      * @param roomId The id of the room
      */
-    getRoom<TPresence extends JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = never>(roomId: string): Room<TPresence, TStorage, TUserMeta, TRoomEvent> | null;
+    getRoom<P extends JsonObject = DP, S extends LsonObject = DS, E extends Json = DE, M extends BaseMetadata = DM>(roomId: string): Room<P, S, U, E, M> | null;
     /**
      * Enter a room.
      * @param roomId The id of the room
      * @param options Optional. You can provide initializers for the Presence or Storage when entering the Room.
      * @returns The room and a leave function. Call the returned leave() function when you no longer need the room.
      */
-    enterRoom<TPresence extends JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = never>(roomId: string, options: EnterOptions<TPresence, TStorage>): {
-        room: Room<TPresence, TStorage, TUserMeta, TRoomEvent>;
+    enterRoom<P extends JsonObject = DP, S extends LsonObject = DS, E extends Json = DE, M extends BaseMetadata = DM>(roomId: string, options: EnterOptions<P, S>): {
+        room: Room<P, S, U, E, M>;
         leave: () => void;
     };
-    /**
-     * @deprecated - Prefer using {@link Client.enterRoom} instead.
-     *
-     * Enters a room and returns it.
-     * @param roomId The id of the room
-     * @param options Optional. You can provide initializers for the Presence or Storage when entering the Room.
-     */
-    enter<TPresence extends JsonObject, TStorage extends LsonObject = LsonObject, TUserMeta extends BaseUserMeta = BaseUserMeta, TRoomEvent extends Json = never>(roomId: string, options: EnterOptions<TPresence, TStorage>): Room<TPresence, TStorage, TUserMeta, TRoomEvent>;
-    /**
-     * @deprecated - Prefer using {@link Client.enterRoom} and calling the returned leave function instead, which is safer.
-     *
-     * Forcefully leaves a room.
-     *
-     * Only call this if you know for sure there are no other "instances" of this
-     * room used elsewhere in your application. Force-leaving can trigger
-     * unexpected conditions in other parts of your application that may not
-     * expect this.
-     *
-     * @param roomId The id of the room
-     */
-    leave(roomId: string): void;
     /**
      * Purges all cached auth tokens and reconnects all rooms that are still
      * connected, if any.
@@ -1917,61 +2210,190 @@ declare type Client = {
      * Call this whenever you log out a user in your application.
      */
     logout(): void;
+    /**
+     * @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]: PrivateClientApi<U, BaseMetadata>;
 };
-declare type AuthEndpoint = string | ((room: string) => Promise<CustomAuthenticationResult>);
+declare type AuthEndpoint = string | ((room?: string) => Promise<CustomAuthenticationResult>);
 /**
  * The authentication endpoint that is called to ensure that the current user has access to a room.
  * Can be an url or a callback if you need to add additional headers.
  */
-declare type ClientOptions = {
+declare type ClientOptions<U extends BaseUserMeta = DU> = {
     throttle?: number;
     lostConnectionTimeout?: number;
     backgroundKeepAliveTimeout?: number;
     polyfills?: Polyfills;
     unstable_fallbackToHTTP?: boolean;
+    unstable_streamData?: boolean;
+    /**
+     * A function that returns a list of user IDs matching a string.
+     */
+    resolveMentionSuggestions?: (args: ResolveMentionSuggestionsArgs) => OptionalPromise<string[]>;
+    /**
+     * A function that returns user info from user IDs.
+     */
+    resolveUsers?: (args: ResolveUsersArgs) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
+    /**
+     * A function that returns room info from room IDs.
+     */
+    resolveRoomsInfo?: (args: ResolveRoomsInfoArgs) => OptionalPromise<(DRI | undefined)[] | undefined>;
+} & ({
+    publicApiKey: string;
+    authEndpoint?: never;
+} | {
+    publicApiKey?: never;
+    authEndpoint: AuthEndpoint;
+});
+/**
+ * Create a client that will be responsible to communicate with liveblocks servers.
+ *
+ * @example
+ * const client = createClient({
+ *   authEndpoint: "/api/auth"
+ * });
+ *
+ * // It's also possible to use a function to call your authentication endpoint.
+ * // Useful to add additional headers or use an API wrapper (like Firebase functions)
+ * const client = createClient({
+ *   authEndpoint: async (room?) => {
+ *     const response = await fetch("/api/auth", {
+ *       method: "POST",
+ *       headers: {
+ *          Authentication: "token",
+ *          "Content-Type": "application/json"
+ *       },
+ *       body: JSON.stringify({ room })
+ *     });
+ *
+ *     return await response.json(); // should be: { token: "..." }
+ *   }
+ * });
+ */
+declare function createClient<U extends BaseUserMeta = DU>(options: ClientOptions<U>): Client<U>;
+declare class NotificationsApiError extends Error {
+    message: string;
+    status: number;
+    details?: JsonObject | undefined;
+    constructor(message: string, status: number, details?: JsonObject | undefined);
+}
+
+declare type CommentBodyParagraphElementArgs = {
+    /**
+     * The paragraph element.
+     */
+    element: CommentBodyParagraph;
+    /**
+     * The text content of the paragraph.
+     */
+    children: string;
+};
+declare type CommentBodyTextElementArgs = {
+    /**
+     * The text element.
+     */
+    element: CommentBodyText;
+};
+declare type CommentBodyLinkElementArgs = {
+    /**
+     * The link element.
+     */
+    element: CommentBodyLink;
+    /**
+     * The absolute URL of the link.
+     */
+    href: string;
+};
+declare type CommentBodyMentionElementArgs<U extends BaseUserMeta = DU> = {
+    /**
+     * The mention element.
+     */
+    element: CommentBodyMention;
+    /**
+     * The mention's user info, if the `resolvedUsers` option was provided.
+     */
+    user?: U["info"];
+};
+declare type StringifyCommentBodyElements<U extends BaseUserMeta = DU> = {
+    /**
+     * The element used to display paragraphs.
+     */
+    paragraph: (args: CommentBodyParagraphElementArgs, index: number) => string;
+    /**
+     * The element used to display text elements.
+     */
+    text: (args: CommentBodyTextElementArgs, index: number) => string;
+    /**
+     * The element used to display links.
+     */
+    link: (args: CommentBodyLinkElementArgs, index: number) => string;
+    /**
+     * The element used to display mentions.
+     */
+    mention: (args: CommentBodyMentionElementArgs<U>, index: number) => string;
+};
+declare type StringifyCommentBodyOptions<U extends BaseUserMeta = DU> = {
     /**
-     * @deprecated Use `polyfills: { fetch: ... }` instead.
-     * This option will be removed in a future release.
+     * Which format to convert the comment to.
      */
-    fetchPolyfill?: Polyfills["fetch"];
+    format?: "plain" | "html" | "markdown";
     /**
-     * @deprecated Use `polyfills: { WebSocket: ... }` instead.
-     * This option will be removed in a future release.
+     * The elements used to customize the resulting string. Each element has
+     * priority over the defaults inherited from the `format` option.
      */
-    WebSocketPolyfill?: Polyfills["WebSocket"];
-} & ({
-    publicApiKey: string;
-    authEndpoint?: never;
-} | {
-    publicApiKey?: never;
-    authEndpoint: AuthEndpoint;
-});
+    elements?: Partial<StringifyCommentBodyElements<U>>;
+    /**
+     * The separator used between paragraphs.
+     */
+    separator?: string;
+    /**
+     * A function that returns user info from user IDs.
+     */
+    resolveUsers?: (args: ResolveUsersArgs) => OptionalPromise<(U["info"] | undefined)[] | undefined>;
+};
 /**
- * Create a client that will be responsible to communicate with liveblocks servers.
- *
- * @example
- * const client = createClient({
- *   authEndpoint: "/api/auth"
- * });
- *
- * // It's also possible to use a function to call your authentication endpoint.
- * // Useful to add additional headers or use an API wrapper (like Firebase functions)
- * const client = createClient({
- *   authEndpoint: async (room) => {
- *     const response = await fetch("/api/auth", {
- *       method: "POST",
- *       headers: {
- *          Authentication: "token",
- *          "Content-Type": "application/json"
- *       },
- *       body: JSON.stringify({ room })
- *     });
- *
- *     return await response.json(); // should be: { token: "..." }
- *   }
- * });
+ * Get an array of each user's ID that has been mentioned in a `CommentBody`.
+ */
+declare function getMentionedIdsFromCommentBody(body: CommentBody): string[];
+/**
+ * Convert a `CommentBody` into either a plain string,
+ * Markdown, HTML, or a custom format.
+ */
+declare function stringifyCommentBody(body: CommentBody, options?: StringifyCommentBodyOptions<BaseUserMeta>): Promise<string>;
+
+/**
+ * Converts a plain comment data object (usually returned by the API) to a comment data object that can be used by the client.
+ * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
+ * @param data The plain comment data object (usually returned by the API)
+ * @returns The rich comment data object that can be used by the client.
+ */
+declare function convertToCommentData(data: CommentDataPlain): CommentData;
+/**
+ * Converts a plain thread data object (usually returned by the API) to a thread data object that can be used by the client.
+ * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
+ * @param data The plain thread data object (usually returned by the API)
+ * @returns The rich thread data object that can be used by the client.
+ */
+declare function convertToThreadData<M extends BaseMetadata>(data: ThreadDataPlain<M>): ThreadData<M>;
+/**
+ * Converts a plain comment reaction object (usually returned by the API) to a comment reaction object that can be used by the client.
+ * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
+ * @param data The plain comment reaction object (usually returned by the API)
+ * @returns The rich comment reaction object that can be used by the client.
+ */
+declare function convertToCommentUserReaction(data: CommentUserReactionPlain): CommentUserReaction;
+/**
+ * Converts a plain inbox notification data object (usually returned by the API) to an inbox notification data object that can be used by the client.
+ * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
+ * @param data The plain inbox notification data object (usually returned by the API)
+ * @returns The rich inbox notification data object that can be used by the client.
  */
-declare function createClient(options: ClientOptions): Client;
+declare function convertToInboxNotificationData(data: InboxNotificationDataPlain): InboxNotificationData;
 
 /**
  * Lookup table for nodes (= SerializedCrdt values) by their IDs.
@@ -1990,7 +2412,7 @@ declare function cloneLson<L extends Lson | undefined>(value: L): L;
 
 declare function lsonToJson(value: Lson): Json;
 declare function patchLiveObjectKey<O extends LsonObject, K extends keyof O, V extends Json>(liveObject: LiveObject<O>, key: K, prev?: V, next?: V): void;
-declare function legacy_patchImmutableObject<S extends JsonObject>(state: S, updates: StorageUpdate[]): S;
+declare function legacy_patchImmutableObject<TState extends JsonObject>(state: TState, updates: StorageUpdate[]): TState;
 
 /**
  * Helper function that can be used to implement exhaustive switch statements
@@ -2035,93 +2457,6 @@ declare function assert(condition: boolean, errmsg: string): asserts condition;
  */
 declare function nn<T>(value: T, errmsg?: string): NonNullable<T>;
 
-declare type PromiseOrNot$1<T> = T | Promise<T>;
-declare type AsyncCacheFunction<T, A extends any[] = any[]> = (...args: A) => PromiseOrNot$1<T>;
-declare type AsyncCacheOptions<T, E> = {
-    isStateEqual?: (a: AsyncState<T, E>, b: AsyncState<T, E>) => boolean;
-};
-declare type AsyncStateInitial = {
-    readonly isLoading: false;
-    readonly data?: never;
-    readonly error?: never;
-};
-declare type AsyncStateLoading<T> = {
-    readonly isLoading: true;
-    readonly data?: T;
-    readonly error?: never;
-};
-declare type AsyncStateSuccess<T> = {
-    readonly isLoading: false;
-    readonly data: T;
-    readonly error?: never;
-};
-declare type AsyncStateError<T, E> = {
-    readonly isLoading: false;
-    readonly data?: T;
-    readonly error: E;
-};
-declare type AsyncState<T, E> = AsyncStateInitial | AsyncStateLoading<T> | AsyncStateSuccess<T> | AsyncStateError<T, E>;
-declare type AsyncStateResolved<T, E> = AsyncStateSuccess<T> | AsyncStateError<T, E>;
-declare type AsyncCacheItem<T, E> = Observable<AsyncState<T, E>> & {
-    get(): Promise<AsyncStateResolved<T, E>>;
-    getState(): AsyncState<T, E>;
-    revalidate(): Promise<AsyncStateResolved<T, E>>;
-};
-declare type AsyncCache<T, E> = {
-    /**
-     * @private
-     *
-     * Creates a key in the cache.
-     *
-     * @param key The key to create.
-     * @param asyncFunction Override the cache's function for this key.
-     */
-    create(key: string, asyncFunction?: AsyncCacheFunction<T, [string]>): AsyncCacheItem<T, E>;
-    /**
-     * Returns a promise which resolves with the state of the key.
-     *
-     * @param key The key to get.
-     */
-    get(key: string): Promise<AsyncStateResolved<T, E>>;
-    /**
-     * Returns the current state of the key synchronously.
-     *
-     * @param key The key to get the state of.
-     */
-    getState(key: string): AsyncState<T, E> | undefined;
-    /**
-     * Revalidates the key.
-     *
-     * @param key The key to revalidate.
-     */
-    revalidate(key: string): Promise<AsyncStateResolved<T, E>>;
-    /**
-     * Subscribes to the key's changes.
-     *
-     * @param key The key to subscribe to.
-     * @param callback The function invoked on every change.
-     */
-    subscribe(key: string, callback: Callback<AsyncState<T, E>>): UnsubscribeCallback;
-    /**
-     * Subscribes to the key's changes once.
-     *
-     * @param key The key to subscribe to.
-     * @param callback The function invoked on every change.
-     */
-    subscribeOnce(key: string, callback: Callback<AsyncState<T, E>>): UnsubscribeCallback;
-    /**
-     * Returns whether a key already exists in the cache.
-     *
-     * @param key The key to look for.
-     */
-    has(key: string): boolean;
-    /**
-     * Clears all keys.
-     */
-    clear(): void;
-};
-declare function createAsyncCache<T, E>(asyncFunction: AsyncCacheFunction<T, [string]>, options?: AsyncCacheOptions<T, E>): AsyncCache<T, E>;
-
 /**
  * Displays a deprecation warning in the dev console. Only in dev mode, and
  * only once per message/key. In production, this is a no-op.
@@ -2167,6 +2502,39 @@ declare namespace fancyConsole {
  */
 declare const freeze: typeof Object.freeze;
 
+/**
+ * Converts an object to a query string
+ * Example:
+ * ```ts
+ * const query = objectToQuery({
+      resolved: true,
+      metadata: {
+        status: "open",
+        priority: 3,
+        org: {
+          startsWith: "liveblocks:",
+        },
+      },
+});
+
+console.log(query);
+// resolved:true AND metadata["status"]:open AND metadata["priority"]:3 AND metadata["org"]^"liveblocks:"
+
+ * ```
+ *
+ *
+ */
+declare type SimpleFilterValue = string | number | boolean;
+declare type OperatorFilterValue = {
+    startsWith: string;
+};
+declare type FilterValue = SimpleFilterValue | OperatorFilterValue;
+declare function objectToQuery(obj: {
+    [key: string]: FilterValue | {
+        [key: string]: FilterValue | undefined;
+    } | undefined;
+}): string;
+
 declare type Poller = {
     start(interval: number): void;
     restart(interval: number): void;
@@ -2282,50 +2650,6 @@ declare function shallow(a: unknown, b: unknown): boolean;
 declare type OmitFirstTupleElement<T extends any[]> = T extends [any, ...infer R] ? R : never;
 declare function stringify(object: Parameters<typeof JSON.stringify>[0], ...args: OmitFirstTupleElement<Parameters<typeof JSON.stringify>>): string;
 
-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 CustomEventTreeNode = {
-    readonly type: "CustomEvent";
-    readonly id: string;
-    readonly key: string;
-    readonly connectionId: number;
-    readonly payload: Json;
-};
-declare type TreeNode = LsonTreeNode | UserTreeNode | CustomEventTreeNode;
-
-type DevToolsTreeNode_CustomEventTreeNode = CustomEventTreeNode;
-type DevToolsTreeNode_JsonTreeNode = JsonTreeNode;
-type DevToolsTreeNode_LiveTreeNode<TName extends `Live${string}` = `Live${string}`> = LiveTreeNode<TName>;
-type DevToolsTreeNode_LsonTreeNode = LsonTreeNode;
-type DevToolsTreeNode_TreeNode = TreeNode;
-type DevToolsTreeNode_UserTreeNode = UserTreeNode;
-declare namespace DevToolsTreeNode {
-  export type { DevToolsTreeNode_CustomEventTreeNode as CustomEventTreeNode, DevToolsTreeNode_JsonTreeNode as JsonTreeNode, DevToolsTreeNode_LiveTreeNode as LiveTreeNode, DevToolsTreeNode_LsonTreeNode as LsonTreeNode, DevToolsTreeNode_TreeNode as TreeNode, DevToolsTreeNode_UserTreeNode as UserTreeNode };
-}
-
 /**
  * Definition of all messages the Panel can send to the Client.
  */
@@ -2446,117 +2770,6 @@ declare namespace protocol {
   export type { protocol_ClientToPanelMessage as ClientToPanelMessage, protocol_FullClientToPanelMessage as FullClientToPanelMessage, protocol_FullPanelToClientMessage as FullPanelToClientMessage, protocol_PanelToClientMessage as PanelToClientMessage };
 }
 
-declare type PromiseOrNot<T> = T | Promise<T>;
-declare type CommentBodyResolveUsersArgs = {
-    /**
-     * The ID of the users to resolve.
-     */
-    userIds: string[];
-};
-declare type CommentBodyParagraphElementArgs = {
-    /**
-     * The paragraph element.
-     */
-    element: CommentBodyParagraph;
-    /**
-     * The text content of the paragraph.
-     */
-    children: string;
-};
-declare type CommentBodyTextElementArgs = {
-    /**
-     * The text element.
-     */
-    element: CommentBodyText;
-};
-declare type CommentBodyLinkElementArgs = {
-    /**
-     * The link element.
-     */
-    element: CommentBodyLink;
-    /**
-     * The absolute URL of the link.
-     */
-    href: string;
-};
-declare type CommentBodyMentionElementArgs<TUserMeta extends BaseUserMeta = BaseUserMeta> = {
-    /**
-     * The mention element.
-     */
-    element: CommentBodyMention;
-    /**
-     * The mention's user info, if the `resolvedUsers` option was provided.
-     */
-    user?: TUserMeta["info"];
-};
-declare type StringifyCommentBodyElements<TUserMeta extends BaseUserMeta = BaseUserMeta> = {
-    /**
-     * The element used to display paragraphs.
-     */
-    paragraph: (args: CommentBodyParagraphElementArgs, index: number) => string;
-    /**
-     * The element used to display text elements.
-     */
-    text: (args: CommentBodyTextElementArgs, index: number) => string;
-    /**
-     * The element used to display links.
-     */
-    link: (args: CommentBodyLinkElementArgs, index: number) => string;
-    /**
-     * The element used to display mentions.
-     */
-    mention: (args: CommentBodyMentionElementArgs<TUserMeta>, index: number) => string;
-};
-declare type StringifyCommentBodyOptions<TUserMeta extends BaseUserMeta = BaseUserMeta> = {
-    /**
-     * Which format to convert the comment to.
-     */
-    format?: "plain" | "html" | "markdown";
-    /**
-     * The elements used to customize the resulting string. Each element has
-     * priority over the defaults inherited from the `format` option.
-     */
-    elements?: Partial<StringifyCommentBodyElements<TUserMeta>>;
-    /**
-     * The separator used between paragraphs.
-     */
-    separator?: string;
-    /**
-     * A function that returns user info from user IDs.
-     */
-    resolveUsers?: (args: CommentBodyResolveUsersArgs) => PromiseOrNot<(TUserMeta["info"] | undefined)[] | undefined>;
-};
-/**
- * Get an array of each user's ID that has been mentioned in a `CommentBody`.
- */
-declare function getMentionedIdsFromCommentBody(body: CommentBody): string[];
-/**
- * Convert a `CommentBody` into either a plain string,
- * Markdown, HTML, or a custom format.
- */
-declare function stringifyCommentBody<TUserMeta extends BaseUserMeta = BaseUserMeta>(body: CommentBody, options?: StringifyCommentBodyOptions<TUserMeta>): Promise<string>;
-/**
- * Converts a plain comment data object (usually returned by the API) to a comment data object that can be used by the client.
- * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
- * @param data The plain comment data object (usually returned by the API)
- * @returns The rich comment data object that can be used by the client.
- */
-declare function convertToCommentData(data: CommentDataPlain): CommentData;
-/**
- * Converts a plain thread data object (usually returned by the API) to a thread data object that can be used by the client.
- * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
- * @param data The plain thread data object (usually returned by the API)
- * @returns The rich hread data object that can be used by the client.
- */
-declare function convertToThreadData<TThreadMetadata extends BaseMetadata = never>(data: ThreadDataPlain<TThreadMetadata>): ThreadData<TThreadMetadata>;
-/**
- * Converts a plain comment reaction object (usually returned by the API) to a comment reaction object that can be used by the client.
- * This is necessary because the plain data object stores dates as ISO strings, but the client expects them as Date objects.
- * @param data The plain comment reaction object (usually returned by the API)
- * @returns The rich comment reaction object that can be used by the client.
- */
-declare function convertToCommentUserReaction(data: CommentUserReactionPlain): CommentUserReaction;
-
 /**
  * Helper type to help users adopt to Lson types from interface definitions.
  * You should only use this to wrap interfaces you don't control. For more
@@ -2569,4 +2782,4 @@ declare type EnsureJson<T> = [
     [K in keyof T]: EnsureJson<T[K]>;
 };
 
-export { type AckOp, type AsyncCache, type AsyncState, type AsyncStateError, type AsyncStateInitial, type AsyncStateLoading, type AsyncStateResolved, type AsyncStateSuccess, type BaseAuthResult, type BaseMetadata, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type Client, type ClientMsg, ClientMsgCode, type CommentBody, type CommentBodyBlockElement, type CommentBodyElement, type CommentBodyInlineElement, type CommentBodyLink, type CommentBodyLinkElementArgs, type CommentBodyMention, type CommentBodyMentionElementArgs, type CommentBodyParagraph, type CommentBodyParagraphElementArgs, type CommentBodyResolveUsersArgs, type CommentBodyText, type CommentBodyTextElementArgs, type CommentData, type CommentDataPlain, type CommentReaction, type CommentUserReaction, type CommentUserReactionPlain, type CommentsApi, CommentsApiError, CrdtType, type CreateListOp, type CreateMapOp, type CreateObjectOp, type CreateOp, type CreateRegisterOp, type CustomAuthenticationResult, type Delegates, type DeleteCrdtOp, type DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, type EnsureJson, type EnterOptions, type EventSource, type FetchStorageClientMsg, type FetchYDocClientMsg, type History, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IdTuple, type Immutable, type InitialDocumentStateServerMsg, type Json, type JsonArray, type JsonObject, type JsonScalar, type LegacyConnectionStatus, LiveList, type LiveListUpdate, LiveMap, type LiveMapUpdate, type LiveNode, LiveObject, type LiveObjectUpdate, type LiveStructure, type LostConnectionEvent, type Lson, type LsonObject, type NodeMap, type Op, OpCode, type Others, type OthersEvent, type ParentToChildNodeMap, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type RejectedStorageOpServerMsg, type Resolve, type Room, type RoomEventMessage, type RoomInitializers, type RoomStateServerMsg, type SerializedChild, type SerializedCrdt, type SerializedList, type SerializedMap, type SerializedObject, type SerializedRegister, type SerializedRootObject, type ServerMsg, ServerMsgCode, type SetParentKeyOp, type Status, type StorageStatus, type StorageUpdate, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, type ThreadData, type ThreadDataPlain, type ThreadsFilterOptions, type ToImmutable, type ToJson, type UnsubscribeCallback, type UpdateObjectOp, type UpdatePresenceClientMsg, type UpdatePresenceServerMsg, type UpdateStorageClientMsg, type UpdateStorageServerMsg, type UpdateYDocClientMsg, type User, type UserJoinServerMsg, type UserLeftServerMsg, WebsocketCloseCodes, type YDocUpdateServerMsg, asPos, assert, assertNever, b64decode, cloneLson, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToThreadData, createAsyncCache, createClient, createCommentsApi, deprecate, deprecateIf, detectDupes, errorIf, freeze, getMentionedIdsFromCommentBody, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, nn, patchLiveObjectKey, raise, shallow, stringify, stringifyCommentBody, throwUsageError, toPlainLson, tryParseJson, withTimeout };
+export { type AckOp, type ActivityData, type BaseAuthResult, type BaseMetadata, type BaseRoomInfo, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type CacheState, type CacheStore, type Client, type ClientMsg, ClientMsgCode, type ClientOptions, 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 CommentReaction, type CommentUserReaction, type CommentUserReactionPlain, CommentsApiError, type CommentsEventServerMsg, CrdtType, type CreateListOp, type CreateMapOp, type CreateObjectOp, type CreateOp, type CreateRegisterOp, type CustomAuthenticationResult, type DE, type DM, type DP, type DRI, type DS, type DU, type Delegates, type DeleteCrdtOp, type DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, type EnsureJson, type EnterOptions, type EventSource, type FetchStorageClientMsg, type FetchYDocClientMsg, type GetThreadsOptions, type History, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IdTuple, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type InboxNotificationThreadData, type InboxNotificationThreadDataPlain, type InitialDocumentStateServerMsg, type Json, type JsonArray, type JsonObject, type JsonScalar, LiveList, type LiveListUpdate, LiveMap, type LiveMapUpdate, type LiveNode, LiveObject, type LiveObjectUpdate, type LiveStructure, LiveblocksError, type LostConnectionEvent, type Lson, type LsonObject, type NodeMap, NotificationsApiError, type Op, OpCode, type OpaqueClient, type OpaqueRoom, type OptionalPromise, type OthersEvent, type ParentToChildNodeMap, type PartialNullable, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type PrivateClientApi, type PrivateRoomApi, type QueryMetadata, type RejectedStorageOpServerMsg, type Resolve, type ResolveMentionSuggestionsArgs, type ResolveRoomsInfoArgs, type ResolveUsersArgs, type Room, type RoomEventMessage, type RoomInitializers, type RoomNotificationSettings, type RoomStateServerMsg, type SerializedChild, type SerializedCrdt, type SerializedList, type SerializedMap, type SerializedObject, type SerializedRegister, type SerializedRootObject, type ServerMsg, ServerMsgCode, type SetParentKeyOp, type Status, type StorageStatus, type StorageUpdate, type Store, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, type ThreadData, type ThreadDataPlain, type ThreadDeleteInfo, type ToImmutable, type ToJson, type UnsubscribeCallback, type UpdateObjectOp, type UpdatePresenceClientMsg, type UpdatePresenceServerMsg, type UpdateStorageClientMsg, type UpdateStorageServerMsg, type UpdateYDocClientMsg, type User, type UserJoinServerMsg, type UserLeftServerMsg, WebsocketCloseCodes, type YDocUpdateServerMsg, ackOp, addReaction, applyOptimisticUpdates, asPos, assert, assertNever, b64decode, cloneLson, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToInboxNotificationData, convertToThreadData, createClient, deleteComment, deprecate, deprecateIf, detectDupes, errorIf, freeze, getMentionedIdsFromCommentBody, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, kInternal, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, nn, objectToQuery, patchLiveObjectKey, raise, removeReaction, shallow, stringify, stringifyCommentBody, throwUsageError, toPlainLson, tryParseJson, upsertComment, withTimeout };