@liveblocks/core 1.9.8-pre1 → 1.10.0-beta2

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,211 @@ 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:
+ *
+ *   40xx: client will disconnect
+ *   41xx: client will reauthorize
+ *   42xx: client will retry without reauthorizing (currently not used)
+ *
+ */
+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
+}
+
+/**
+ * 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.
+ *
+ * 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 type Delegates<T extends BaseAuthResult> = {
+    authenticate: () => Promise<T>;
+    createSocket: (authValue: T) => IWebSocketInstance;
+    canZombie: () => boolean;
+};
+
 declare enum OpCode {
     INIT = 0,
     SET_PARENT_KEY = 1,
@@ -203,77 +421,27 @@ 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.
+ * Helper type to convert any valid Lson type to the equivalent Json type.
+ *
+ * Examples:
+ *
+ *   ToImmutable<42>                         // 42
+ *   ToImmutable<'hi'>                       // 'hi'
+ *   ToImmutable<number>                     // number
+ *   ToImmutable<string>                     // string
+ *   ToImmutable<string | LiveList<number>>  // string | readonly number[]
+ *   ToImmutable<LiveMap<string, LiveList<number>>>
+ *                                           // ReadonlyMap<string, readonly number[]>
+ *   ToImmutable<LiveObject<{ a: number, b: LiveList<string>, c?: number }>>
+ *                                           // { readonly a: null, readonly b: readonly string[], readonly c?: number }
+ *
  */
-declare type LiveObjectUpdates<TData extends LsonObject> = {
-    type: "LiveObject";
-    node: LiveObject<TData>;
-    updates: LiveObjectUpdateDelta<TData>;
-};
+declare type ToImmutable<L extends Lson | LsonObject> = L extends LiveList<infer I> ? readonly ToImmutable<I>[] : L extends LiveObject<infer O> ? ToImmutable<O> : L extends LiveMap<infer K, infer V> ? ReadonlyMap<K, ToImmutable<V>> : L extends LsonObject ? {
+    readonly [K in keyof L]: ToImmutable<Exclude<L[K], undefined>> | (undefined extends L[K] ? undefined : never);
+} : L extends Json ? L : never;
 /**
- * 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.
- *
- * Examples:
- *
- *   ToImmutable<42>                         // 42
- *   ToImmutable<'hi'>                       // 'hi'
- *   ToImmutable<number>                     // number
- *   ToImmutable<string>                     // string
- *   ToImmutable<string | LiveList<number>>  // string | readonly number[]
- *   ToImmutable<LiveMap<string, LiveList<number>>>
- *                                           // ReadonlyMap<string, readonly number[]>
- *   ToImmutable<LiveObject<{ a: number, b: LiveList<string>, c?: number }>>
- *                                           // { readonly a: null, readonly b: readonly string[], readonly c?: number }
- *
- */
-declare type ToImmutable<L extends Lson | LsonObject> = L extends LiveList<infer I> ? readonly ToImmutable<I>[] : L extends LiveObject<infer O> ? ToImmutable<O> : L extends LiveMap<infer K, infer V> ? ReadonlyMap<K, ToImmutable<V>> : L extends LsonObject ? {
-    readonly [K in keyof L]: ToImmutable<Exclude<L[K], undefined>> | (undefined extends L[K] ? undefined : never);
-} : L extends Json ? L : never;
-/**
- * Returns PlainLson for a given Json or LiveStructure, suitable for calling the storage init api
+ * Returns PlainLson for a given Json or LiveStructure, suitable for calling the storage init api
  */
 declare function toPlainLson(lson: Lson): PlainLson;
 
@@ -550,464 +718,99 @@ 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;
-};
-
-/**
- * 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 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"
-}
-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 DateToString<T> = {
-    [P in keyof T]: T[P] extends Date ? string : T[P];
-};
-
-declare type CommentReaction = {
-    emoji: string;
-    createdAt: Date;
-    users: {
-        id: string;
-    }[];
+declare type LiveObjectUpdateDelta<O extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof O]?: UpdateDelta | undefined;
 };
 /**
- * Represents a comment.
+ * 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 CommentData = {
-    type: "comment";
-    id: string;
-    threadId: string;
-    roomId: string;
-    userId: string;
-    createdAt: Date;
-    editedAt?: Date;
-    reactions: CommentReaction[];
-} & ({
-    body: CommentBody;
-    deletedAt?: never;
-} | {
-    body?: never;
-    deletedAt: Date;
-});
-declare type CommentDataPlain = Omit<DateToString<CommentData>, "reaction" | "body"> & {
-    reactions: DateToString<CommentReaction[]>;
-} & ({
-    body: CommentBody;
-    deletedAt?: never;
-} | {
-    body?: never;
-    deletedAt: string;
-});
-
-declare type CommentUserReaction = {
-    emoji: string;
-    createdAt: Date;
-    userId: string;
+declare type LiveObjectUpdates<TData extends LsonObject> = {
+    type: "LiveObject";
+    node: LiveObject<TData>;
+    updates: LiveObjectUpdateDelta<TData>;
 };
-declare type CommentUserReactionPlain = DateToString<CommentUserReaction>;
-
 /**
- * Represents a thread of comments.
+ * 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 ThreadData<TThreadMetadata extends BaseMetadata = never> = {
-    type: "thread";
-    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 GetThreadsOptions<TThreadMetadata extends BaseMetadata> = {
-    query?: {
-        metadata?: Partial<TThreadMetadata>;
-    };
-};
-declare type CommentsApi<TThreadMetadata extends BaseMetadata> = {
-    getThreads(options?: GetThreadsOptions<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;
+declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
+    constructor(obj?: O);
     /**
-     * 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.
+     * Transform the LiveObject into a javascript object
      */
-    clear(): void;
+    toObject(): O;
     /**
-     * Returns the number of active subscribers.
+     * 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
      */
-    count(): number;
+    set<TKey extends keyof O>(key: TKey, value: O[TKey]): void;
     /**
-     * Pauses event delivery until unpaused. Any .notify() calls made while
-     * paused will get buffered into memory and emitted later.
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
      */
-    pause(): void;
+    get<TKey extends keyof O>(key: TKey): O[TKey];
     /**
-     * Emits all in-memory buffered events, and unpauses. Any .notify() calls
-     * made after this will be synchronously delivered again.
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
      */
-    unpause(): void;
+    delete(key: keyof O): void;
     /**
-     * Observable instance, which can be used to subscribe to this event source
-     * in a readonly fashion. Safe to publicly expose.
+     * Adds or updates multiple properties at once with an object.
+     * @param patch The object used to overrides properties
      */
-    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 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
+    update(patch: Partial<O>): void;
+    toImmutable(): ToImmutable<O>;
+    clone(): LiveObject<O>;
 }
 
 /**
- * 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.
+ * Use this symbol to brand an object property as internal.
  *
- * 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.
+ * @example
+ * Object.defineProperty(
+ *   {
+ *     public,
+ *     [kInternal]: {
+ *       private
+ *     },
+ *   },
+ *   kInternal,
+ *   {
+ *     enumerable: false,
+ *   }
+ * );
  */
-declare type LostConnectionEvent = "lost" | "restored" | "failed";
+declare const kInternal: unique symbol;
+
 /**
- * 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).
+ * 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 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 {
@@ -1337,6 +1140,137 @@ declare type RejectedStorageOpServerMsg = {
     readonly reason: 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 DateToString<T> = {
+    [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 CommentReaction = {
+    emoji: string;
+    createdAt: Date;
+    users: {
+        id: string;
+    }[];
+};
+/**
+ * Represents a comment.
+ */
+declare type CommentData = {
+    type: "comment";
+    id: string;
+    threadId: string;
+    roomId: string;
+    userId: string;
+    createdAt: Date;
+    editedAt?: Date;
+    reactions: CommentReaction[];
+} & ({
+    body: CommentBody;
+    deletedAt?: never;
+} | {
+    body?: never;
+    deletedAt: Date;
+});
+declare type CommentDataPlain = Omit<DateToString<CommentData>, "reactions" | "body"> & {
+    reactions: DateToString<CommentReaction[]>;
+} & ({
+    body: CommentBody;
+    deletedAt?: never;
+} | {
+    body?: never;
+    deletedAt: string;
+});
+
+declare type CommentUserReaction = {
+    emoji: string;
+    createdAt: Date;
+    userId: string;
+};
+declare type CommentUserReactionPlain = DateToString<CommentUserReaction>;
+
+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 };
+}
+
+declare type InboxNotificationThreadData = {
+    kind: "thread";
+    id: string;
+    roomId: string;
+    threadId: string;
+    notifiedAt: Date;
+    readAt: Date | null;
+};
+declare type InboxNotificationData = InboxNotificationThreadData;
+declare type InboxNotificationDataPlain = DateToString<InboxNotificationData>;
+
 /**
  * Represents a user connected in a room. Treated as immutable.
  */
@@ -1396,6 +1330,32 @@ declare type OthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUse
     others: readonly User<TPresence, TUserMeta>[];
 }>;
 
+declare type PartialNullable<T> = {
+    [P in keyof T]?: T[P] | null | undefined;
+};
+
+declare type RoomThreadsNotificationSettings = "all" | "replies_and_mentions" | "none";
+declare type RoomNotificationSettings = {
+    threads: RoomThreadsNotificationSettings;
+};
+
+/**
+ * Represents a thread of comments.
+ */
+declare type ThreadData<TThreadMetadata extends BaseMetadata = never> = {
+    type: "thread";
+    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 LegacyOthersEvent<TPresence extends JsonObject, TUserMeta extends BaseUserMeta> = {
     type: "leave";
     user: User<TPresence, TUserMeta>;
@@ -1670,9 +1630,95 @@ declare type SubscribeFn<TPresence extends JsonObject, _TStorage extends LsonObj
      *   }
      * });
      */
-    (type: "storage-status", listener: Callback<StorageStatus>): () => void;
+    (type: "storage-status", listener: Callback<StorageStatus>): () => void;
+};
+declare type GetThreadsOptions<TThreadMetadata extends BaseMetadata> = {
+    query?: {
+        metadata?: Partial<TThreadMetadata>;
+    };
+};
+declare type CommentsApi<TThreadMetadata extends BaseMetadata = never> = {
+    /**
+     * @private
+     */
+    getThreads(options?: GetThreadsOptions<TThreadMetadata>): Promise<{
+        threads: ThreadData<TThreadMetadata>[];
+        inboxNotifications: InboxNotificationData[];
+    }>;
+    /**
+     * @private
+     */
+    getThread(options: {
+        threadId: string;
+    }): Promise<{
+        thread: ThreadData<TThreadMetadata>;
+        inboxNotification?: InboxNotificationData;
+    } | undefined>;
+    /**
+     * @private
+     */
+    createThread(options: {
+        threadId: string;
+        commentId: string;
+        metadata: TThreadMetadata | undefined;
+        body: CommentBody;
+    }): Promise<ThreadData<TThreadMetadata>>;
+    /**
+     * @private
+     */
+    editThreadMetadata(options: {
+        metadata: PartialNullable<TThreadMetadata>;
+        threadId: string;
+    }): Promise<TThreadMetadata>;
+    /**
+     * @private
+     */
+    createComment(options: {
+        threadId: string;
+        commentId: string;
+        body: CommentBody;
+    }): Promise<CommentData>;
+    /**
+     * @private
+     */
+    editComment(options: {
+        threadId: string;
+        commentId: string;
+        body: CommentBody;
+    }): Promise<CommentData>;
+    /**
+     * @private
+     */
+    deleteComment(options: {
+        threadId: string;
+        commentId: string;
+    }): Promise<void>;
+    /**
+     * @private
+     */
+    addReaction(options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }): Promise<CommentUserReaction>;
+    /**
+     * @private
+     */
+    removeReaction(options: {
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }): Promise<void>;
 };
 declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = CommentsApi<any> & {
+    /**
+     * @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]: PrivateRoomApi;
     /**
      * The id of the room.
      */
@@ -1810,6 +1856,14 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
         readonly ydoc: Observable<YDocUpdateServerMsg | UpdateYDocClientMsg>;
         readonly comments: Observable<CommentsEventServerMsg>;
     };
+    /**
+     * @private
+     */
+    getRoomNotificationSettings(): Promise<RoomNotificationSettings>;
+    /**
+     * @private
+     */
+    updateRoomNotificationSettings(settings: Partial<RoomNotificationSettings>): Promise<RoomNotificationSettings>;
     /**
      * Batches modifications made during the given function.
      * All the modifications are sent to other clients in a single message.
@@ -1857,6 +1911,29 @@ 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 = {
+    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;
+    };
+};
+declare type HistoryOp<TPresence extends JsonObject> = Op | {
+    readonly type: "presence";
+    readonly data: TPresence;
+};
 declare type Polyfills = {
     atob?: (data: string) => string;
     fetch?: typeof fetch;
@@ -1883,7 +1960,177 @@ declare type RoomInitializers<TPresence extends JsonObject, TStorage extends Lso
     /** @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 OptimisticUpdate<TThreadMetadata extends BaseMetadata> = CreateThreadOptimisticUpdate<TThreadMetadata> | EditThreadMetadataOptimisticUpdate<TThreadMetadata> | CreateCommentOptimisticUpdate | EditCommentOptimisticUpdate | DeleteCommentOptimisticUpdate | AddReactionOptimisticUpdate | RemoveReactionOptimisticUpdate | MarkInboxNotificationAsReadOptimisticUpdate | MarkAllInboxNotificationsAsReadOptimisticUpdate | UpdateNotificationSettingsOptimisticUpdate;
+declare type CreateThreadOptimisticUpdate<TThreadMetadata extends BaseMetadata> = {
+    type: "create-thread";
+    id: string;
+    thread: ThreadData<TThreadMetadata>;
+};
+declare type EditThreadMetadataOptimisticUpdate<TThreadMetadata extends BaseMetadata> = {
+    type: "edit-thread-metadata";
+    id: string;
+    threadId: string;
+    metadata: Resolve<PartialNullable<TThreadMetadata>>;
+};
+declare type CreateCommentOptimisticUpdate = {
+    type: "create-comment";
+    id: string;
+    comment: CommentData;
+    inboxNotificationId?: string;
+};
+declare type EditCommentOptimisticUpdate = {
+    type: "edit-comment";
+    id: string;
+    threadId: string;
+    editedAt: Date;
+    commentId: string;
+    body: CommentBody;
+};
+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;
+    emoji: string;
+    createdAt: Date;
+    userId: string;
+};
+declare type RemoveReactionOptimisticUpdate = {
+    type: "remove-reaction";
+    id: string;
+    threadId: string;
+    commentId: string;
+    emoji: string;
+    userId: string;
+};
+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<TThreadMetadata extends BaseMetadata> = {
+    /**
+     * Threads by ID.
+     */
+    threads: Record<string, ThreadData<TThreadMetadata>>;
+    /**
+     * 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<TThreadMetadata>[];
+    /**
+     * Inbox notifications by ID.
+     */
+    inboxNotifications: Record<string, InboxNotificationData>;
+    /**
+     * Notification settings per room id
+     */
+    notificationSettings: Record<string, RoomNotificationSettings>;
+};
+interface CacheStore<TThreadMetadata extends BaseMetadata> extends Store<CacheState<TThreadMetadata>> {
+    deleteThread(threadId: string): void;
+    updateThreadAndNotification(thread: ThreadData<TThreadMetadata>, inboxNotification?: InboxNotificationData): void;
+    updateThreadsAndNotifications(threads: ThreadData<TThreadMetadata>[], inboxNotifications: InboxNotificationData[], queryKey?: string): void;
+    pushOptimisticUpdate(optimisticUpdate: OptimisticUpdate<TThreadMetadata>): void;
+    setQueryState(queryKey: string, queryState: QueryState): void;
+}
+declare function applyOptimisticUpdates<TThreadMetadata extends BaseMetadata>(state: CacheState<TThreadMetadata>): Pick<CacheState<TThreadMetadata>, "threads" | "inboxNotifications" | "notificationSettings">;
+
+declare type OptionalPromise<T> = T | Promise<T>;
+
+declare type RoomInfo = {
+    /**
+     * The name of the room.
+     */
+    name?: string;
+};
 
+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<TPresence extends JsonObject, TStorage extends LsonObject> = Resolve<RoomInitializers<TPresence, TStorage> & {
     /**
      * Only necessary when you’re using Liveblocks with React v17 or lower.
@@ -1895,7 +2142,42 @@ 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<TUserMeta extends BaseUserMeta> = {
+    currentUserIdStore: Store<string | null>;
+    resolveMentionSuggestions: ClientOptions["resolveMentionSuggestions"];
+    cacheStore: CacheStore<BaseMetadata>;
+    usersStore: BatchStore<TUserMeta["info"] | undefined, [string]>;
+    roomsInfoStore: BatchStore<RoomInfo | undefined, [string]>;
+};
+declare type InboxNotificationsApi<TThreadMetadata extends BaseMetadata = never> = {
+    /**
+     * @private
+     */
+    getInboxNotifications(): Promise<{
+        inboxNotifications: InboxNotificationData[];
+        threads: ThreadData<TThreadMetadata>[];
+    }>;
+    /**
+     * @private
+     */
+    getUnreadInboxNotificationsCount(): Promise<number>;
+    /**
+     * @private
+     */
+    markAllInboxNotificationsAsRead(): Promise<void>;
+    /**
+     * @private
+     */
+    markInboxNotificationAsRead(inboxNotificationId: string): Promise<void>;
+};
+declare type Client<TUserMeta extends BaseUserMeta = BaseUserMeta> = InboxNotificationsApi & {
     /**
      * Gets a room. Returns null if {@link Client.enter} has not been called previously.
      *
@@ -1940,13 +2222,21 @@ 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<TUserMeta>;
 };
-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<TUserMeta extends BaseUserMeta = BaseUserMeta> = {
     throttle?: number;
     lostConnectionTimeout?: number;
     backgroundKeepAliveTimeout?: number;
@@ -1954,48 +2244,177 @@ declare type ClientOptions = {
     unstable_fallbackToHTTP?: boolean;
     unstable_streamData?: boolean;
     /**
-     * @deprecated Use `polyfills: { fetch: ... }` instead.
-     * This option will be removed in a future release.
+     * @deprecated Use `polyfills: { fetch: ... }` instead.
+     * This option will be removed in a future release.
+     */
+    fetchPolyfill?: Polyfills["fetch"];
+    /**
+     * @deprecated Use `polyfills: { WebSocket: ... }` instead.
+     * This option will be removed in a future release.
+     */
+    WebSocketPolyfill?: Polyfills["WebSocket"];
+    /**
+     * @beta
+     *
+     * A function that returns a list of user IDs matching a string.
+     */
+    resolveMentionSuggestions?: (args: ResolveMentionSuggestionsArgs) => OptionalPromise<string[]>;
+    /**
+     * @beta
+     *
+     * A function that returns user info from user IDs.
+     */
+    resolveUsers?: (args: ResolveUsersArgs) => OptionalPromise<(TUserMeta["info"] | undefined)[] | undefined>;
+    /**
+     * @beta
+     *
+     * A function that returns room info from room IDs.
+     */
+    resolveRoomsInfo?: (args: ResolveRoomsInfoArgs) => OptionalPromise<(RoomInfo | 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<TUserMeta extends BaseUserMeta = BaseUserMeta>(options: ClientOptions<TUserMeta>): Client<TUserMeta>;
+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<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.
      */
-    fetchPolyfill?: Polyfills["fetch"];
+    elements?: Partial<StringifyCommentBodyElements<TUserMeta>>;
     /**
-     * @deprecated Use `polyfills: { WebSocket: ... }` instead.
-     * This option will be removed in a future release.
+     * The separator used between paragraphs.
      */
-    WebSocketPolyfill?: Polyfills["WebSocket"];
-} & ({
-    publicApiKey: string;
-    authEndpoint?: never;
-} | {
-    publicApiKey?: never;
-    authEndpoint: AuthEndpoint;
-});
+    separator?: string;
+    /**
+     * A function that returns user info from user IDs.
+     */
+    resolveUsers?: (args: ResolveUsersArgs) => OptionalPromise<(TUserMeta["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<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 thread data object that can be used by the client.
  */
-declare function createClient(options: ClientOptions): 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;
 
 /**
  * Lookup table for nodes (= SerializedCrdt values) by their IDs.
@@ -2059,93 +2478,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.
@@ -2306,50 +2638,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.
  */
@@ -2470,117 +2758,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
@@ -2593,4 +2770,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 GetThreadsOptions, 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 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, 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 BaseAuthResult, type BaseMetadata, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type CacheState, type CacheStore, 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 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 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 InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationThreadData, 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, NotificationsApiError, type Op, OpCode, type OptionalPromise, type Others, type OthersEvent, type ParentToChildNodeMap, type PartialNullable, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type RejectedStorageOpServerMsg, type Resolve, type ResolveMentionSuggestionsArgs, type ResolveRoomsInfoArgs, type ResolveUsersArgs, type Room, type RoomEventMessage, type RoomInfo, 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 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, applyOptimisticUpdates, asPos, assert, assertNever, b64decode, cloneLson, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToThreadData, createClient, deprecate, deprecateIf, detectDupes, errorIf, freeze, getMentionedIdsFromCommentBody, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, kInternal, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, nn, patchLiveObjectKey, raise, shallow, stringify, stringifyCommentBody, throwUsageError, toPlainLson, tryParseJson, withTimeout };