@liveblocks/core 1.2.0-comments4 → 1.2.0-comments6

package/dist/index.d.mts

@@ -5,19 +5,6 @@
 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:
@@ -38,239 +25,6 @@ declare function isJsonScalar(data: Json): data is JsonScalar;
 declare function isJsonArray(data: Json): data is JsonArray;
 declare function isJsonObject(data: Json): data is JsonObject;
 
-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?: Json;
-    [other: string]: Json | undefined;
-} & JwtMeta;
-/**
- * New authorization Access Token.
- */
-declare type AccessToken = {
-    k: TokenKind.ACCESS_TOKEN;
-    pid: string;
-    uid: string;
-    perms: LiveblocksPermissions;
-    ui?: Json;
-} & JwtMeta;
-/**
- * New authorization ID Token.
- */
-declare type IDToken = {
-    k: TokenKind.ID_TOKEN;
-    pid: string;
-    uid: string;
-    gids?: string[];
-    ui?: Json;
-} & JwtMeta;
-declare type AuthToken = AccessToken | IDToken | LegacySecretToken;
-declare type ParsedAuthToken = {
-    readonly raw: string;
-    readonly parsed: AuthToken;
-};
-
-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: number;
-    readonly wasClean: boolean;
-    readonly reason: string;
-}
-interface IWebSocketMessageEvent extends IWebSocketEvent {
-    readonly data: string | Buffer | ArrayBuffer | readonly Buffer[];
-}
-interface IWebSocketInstance {
-    readonly CONNECTING: number;
-    readonly OPEN: number;
-    readonly CLOSING: number;
-    readonly CLOSED: number;
-    readonly readyState: number;
-    addEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
-    addEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
-    addEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
-    removeEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
-    removeEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
-    removeEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
-    close(): void;
-    send(data: string): void;
-}
-/**
- * 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;
-};
-
 declare enum OpCode {
     INIT = 0,
     SET_PARENT_KEY = 1,
@@ -439,15 +193,64 @@ declare type PlainLsonList = {
 };
 declare type PlainLson = PlainLsonObject | PlainLsonMap | PlainLsonList | Json;
 
+declare type LiveObjectUpdateDelta<O extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof O]?: UpdateDelta | undefined;
+};
 /**
- * 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
+ * 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>;
+}
+
+/**
+ * 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[]>
@@ -722,100 +525,395 @@ declare type LsonObject = {
  *                                      // { a: null, b: string[], c?: number }
  *
  */
-declare type ToJson<T extends Lson | LsonObject> = T extends Json ? T : T extends LsonObject ? {
-    [K in keyof T]: ToJson<Exclude<T[K], undefined>> | (undefined extends T[K] ? undefined : never);
-} : T extends LiveList<infer I> ? ToJson<I>[] : T extends LiveObject<infer O> ? ToJson<O> : T extends LiveMap<infer KS, infer V> ? {
-    [K in KS]: ToJson<V>;
-} : never;
+declare type ToJson<T extends Lson | LsonObject> = T extends Json ? T : T extends LsonObject ? {
+    [K in keyof T]: ToJson<Exclude<T[K], undefined>> | (undefined extends T[K] ? undefined : never);
+} : T extends LiveList<infer I> ? ToJson<I>[] : T extends LiveObject<infer O> ? ToJson<O> : T extends LiveMap<infer KS, infer V> ? {
+    [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 BaseUserInfo = {
+    [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?: BaseUserInfo;
+};
+
+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?: BaseUserInfo;
+    [other: string]: Json | undefined;
+} & JwtMeta;
+/**
+ * New authorization Access Token.
+ */
+declare type AccessToken = {
+    k: TokenKind.ACCESS_TOKEN;
+    pid: string;
+    uid: string;
+    perms: LiveblocksPermissions;
+    ui?: BaseUserInfo;
+} & JwtMeta;
+/**
+ * New authorization ID Token.
+ */
+declare type IDToken = {
+    k: TokenKind.ID_TOKEN;
+    pid: string;
+    uid: string;
+    gids?: string[];
+    ui?: BaseUserInfo;
+} & 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;
+declare type CommentBodyElement = CommentBodyBlockElement | CommentBodyInlineElement;
+declare type CommentBodyParagraph = {
+    type: "paragraph";
+    children: CommentBodyInlineElement[];
+};
+declare type CommentBodyMention = {
+    type: "mention";
+    id: string;
+};
+declare type CommentBodyText = {
+    bold?: boolean;
+    italic?: boolean;
+    strikethrough?: boolean;
+    code?: boolean;
+    text: string;
+};
+declare type CommentBody = {
+    version: 1;
+    content: CommentBodyBlockElement[];
+};
+
+declare type CommentData = {
+    type: "comment";
+    id: string;
+    threadId: string;
+    roomId: string;
+    userId: string;
+    createdAt: string;
+    editedAt?: string;
+} & ({
+    body: CommentBody;
+    mentionedIds: string[];
+    deletedAt?: never;
+} | {
+    body?: never;
+    mentionedIds: [];
+    deletedAt: string;
+});
+
+declare type ThreadData<ThreadMetadata extends BaseMetadata = never> = {
+    type: "thread";
+    id: string;
+    roomId: string;
+    createdAt: string;
+    updatedAt?: string;
+    comments: CommentData[];
+    metadata: [ThreadMetadata] extends [never] ? Record<string, never> : ThreadMetadata;
+};
+
+declare type Options = {
+    serverEndpoint: string;
+};
+declare type CommentsApi<ThreadMetadata extends BaseMetadata> = {
+    getThreads(): Promise<ThreadData<ThreadMetadata>[]>;
+    createThread(options: {
+        threadId: string;
+        commentId: string;
+        metadata: ThreadMetadata | undefined;
+        body: CommentBody;
+    }): Promise<ThreadData<ThreadMetadata>>;
+    editThreadMetadata(options: {
+        metadata: Partial<ThreadMetadata>;
+        threadId: string;
+    }): Promise<ThreadData<ThreadMetadata>>;
+    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>;
+};
+declare function createCommentsApi<ThreadMetadata extends BaseMetadata>(roomId: string, getAuthValue: () => Promise<AuthValue>, { serverEndpoint }: Options): CommentsApi<ThreadMetadata>;
+
+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: number;
+    readonly wasClean: boolean;
+    readonly reason: string;
+}
+interface IWebSocketMessageEvent extends IWebSocketEvent {
+    readonly data: string | Buffer | ArrayBuffer | readonly Buffer[];
+}
+interface IWebSocketInstance {
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    readonly CLOSING: number;
+    readonly CLOSED: number;
+    readonly readyState: number;
+    addEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
+    addEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
+    addEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
+    removeEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
+    removeEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
+    removeEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
+    close(): void;
+    send(data: string): void;
+}
+/**
+ * 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
+}
 
-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.
+ * Old connection statuses, here for backward-compatibility reasons only.
  */
-declare type LiveObjectUpdates<TData extends LsonObject> = {
-    type: "LiveObject";
-    node: LiveObject<TData>;
-    updates: LiveObjectUpdateDelta<TData>;
-};
+declare type LegacyConnectionStatus = "closed" | "authenticating" | "connecting" | "open" | "unavailable" | "failed";
 /**
- * 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.
+ * 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 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>;
-}
-
+declare type Status = "initial" | "connecting" | "connected" | "reconnecting" | "disconnected";
 /**
- * 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.
+ * Used to report about app-level reconnection issues.
  *
- * This trick comes from:
- * https://effectivetypescript.com/2022/02/25/gentips-4-display/
+ * 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 Resolve<T> = T extends (...args: unknown[]) => unknown ? T : {
-    [K in keyof T]: T[K];
-};
-
+declare type LostConnectionEvent = "lost" | "restored" | "failed";
 /**
- * This type is used by clients to define the metadata for a user.
+ * 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 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?: Json;
+declare type BaseAuthResult = NonNullable<Json>;
+declare type Delegates<T extends BaseAuthResult> = {
+    authenticate: () => Promise<T>;
+    createSocket: (authValue: T) => IWebSocketInstance;
 };
 
 declare type IdTuple<T> = [id: string, value: T];
@@ -867,12 +965,41 @@ declare enum ServerMsgCode {
     INITIAL_STORAGE_STATE = 200,
     UPDATE_STORAGE = 201,
     REJECT_STORAGE_OP = 299,
-    UPDATE_YDOC = 300
+    UPDATE_YDOC = 300,
+    THREAD_CREATED = 400,
+    THREAD_METADATA_UPDATED = 401,
+    COMMENT_CREATED = 402,
+    COMMENT_EDITED = 403,
+    COMMENT_DELETED = 404
 }
 /**
  * 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 | YDocUpdate;
+declare type ServerMsg<TPresence extends JsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = UpdatePresenceServerMsg<TPresence> | UserJoinServerMsg<TUserMeta> | UserLeftServerMsg | BroadcastedEventServerMsg<TRoomEvent> | RoomStateServerMsg<TUserMeta> | InitialDocumentStateServerMsg | UpdateStorageServerMsg | RejectedStorageOpServerMsg | YDocUpdate | CommentsEventServerMsg;
+declare type CommentsEventServerMsg = ThreadCreatedEvent | ThreadMetadataUpdatedEvent | CommentCreatedEvent | CommentEditedEvent | CommentDeletedEvent;
+declare type ThreadCreatedEvent = {
+    type: ServerMsgCode.THREAD_CREATED;
+    threadId: string;
+};
+declare type ThreadMetadataUpdatedEvent = {
+    type: ServerMsgCode.THREAD_METADATA_UPDATED;
+    threadId: string;
+};
+declare type CommentCreatedEvent = {
+    type: ServerMsgCode.COMMENT_CREATED;
+    threadId: string;
+    commentId: string;
+};
+declare type CommentEditedEvent = {
+    type: ServerMsgCode.COMMENT_EDITED;
+    threadId: string;
+    commentId: string;
+};
+declare type CommentDeletedEvent = {
+    type: ServerMsgCode.COMMENT_DELETED;
+    threadId: string;
+    commentId: string;
+};
 /**
  * Sent by the WebSocket server and broadcasted to all clients to announce that
  * a User updated their presence. For example, when a user moves their cursor.
@@ -1078,6 +1205,10 @@ declare type User<TPresence extends JsonObject, TUserMeta extends BaseUserMeta>
      * can only read but not mutate it.
      */
     readonly canWrite: boolean;
+    /**
+     * True if the user can comment on a thread
+     */
+    readonly canComment: boolean;
 };
 
 /**
@@ -1345,7 +1476,7 @@ 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> = {
+declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUserMeta extends BaseUserMeta, TRoomEvent extends Json> = CommentsApi<any> & {
     /**
      * The id of the room.
      */
@@ -1490,6 +1621,7 @@ declare type Room<TPresence extends JsonObject, TStorage extends LsonObject, TUs
         readonly storageDidLoad: Observable<void>;
         readonly storageStatus: Observable<StorageStatus>;
         readonly ydoc: Observable<YDocUpdate>;
+        readonly comments: Observable<CommentsEventServerMsg>;
     };
     /**
      * Batches modifications made during the given function.
@@ -1544,51 +1676,6 @@ declare type RoomInitializers<TPresence extends JsonObject, TStorage extends Lso
     shouldInitiallyConnect?: boolean;
 }>;
 
-declare type AuthValue = {
-    type: "secret";
-    token: ParsedAuthToken;
-} | {
-    type: "public";
-    publicApiKey: string;
-};
-declare type RequestedScope = "room:read" | "comments:read";
-declare type AuthManager = {
-    getAuthValue(requestedScope: RequestedScope, roomId: string): Promise<AuthValue>;
-};
-
-declare type BaseThreadRealtimeEvent = {
-    roomId: string;
-    threadId: string;
-};
-declare type BaseCommentRealtimeEvent = BaseThreadRealtimeEvent & {
-    commentId: string;
-};
-declare type ThreadCreatedRealtimeEvent = BaseThreadRealtimeEvent & {
-    type: "threadCreated";
-};
-declare type ThreadUpdatedRealtimeEvent = BaseThreadRealtimeEvent & {
-    type: "threadUpdated";
-};
-declare type ThreadDeletedRealtimeEvent = BaseThreadRealtimeEvent & {
-    type: "threadDeleted";
-};
-declare type CommentCreatedRealtimeEvent = BaseCommentRealtimeEvent & {
-    type: "commentCreated";
-};
-declare type CommentUpdatedRealtimeEvent = BaseCommentRealtimeEvent & {
-    type: "commentEdited";
-};
-declare type CommentDeletedRealtimeEvent = BaseCommentRealtimeEvent & {
-    type: "commentDeleted";
-};
-declare type RealtimeEvent = ThreadCreatedRealtimeEvent | ThreadUpdatedRealtimeEvent | ThreadDeletedRealtimeEvent | CommentCreatedRealtimeEvent | CommentUpdatedRealtimeEvent | CommentDeletedRealtimeEvent;
-
-declare type RealtimeClient = {
-    subscribeToEvents: (roomId: string, callback: Callback<RealtimeEvent>) => UnsubscribeCallback;
-    error: Observable<Error>;
-    connection: Observable<Status>;
-};
-
 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.
@@ -1601,10 +1688,6 @@ declare type EnterOptions<TPresence extends JsonObject, TStorage extends LsonObj
     unstable_batchedUpdates?: (cb: () => void) => void;
 }>;
 declare type Client = {
-    __internal: {
-        getAuthValue: AuthManager["getAuthValue"];
-        realtimeClient: RealtimeClient;
-    };
     /**
      * Gets a room. Returns null if {@link Client.enter} has not been called previously.
      *
@@ -2190,103 +2273,6 @@ declare namespace protocol {
   };
 }
 
-declare type BaseMetadata = Record<string, string | boolean | number>;
-
-declare type CommentBodyBlockElement = CommentBodyParagraph;
-declare type CommentBodyInlineElement = CommentBodyText | CommentBodyMention;
-declare type CommentBodyElement = CommentBodyBlockElement | CommentBodyInlineElement;
-declare type CommentBodyParagraph = {
-    type: "paragraph";
-    children: CommentBodyInlineElement[];
-};
-declare type CommentBodyMention = {
-    type: "mention";
-    userId: string;
-};
-declare type CommentBodyText = {
-    bold?: boolean;
-    italic?: boolean;
-    strikethrough?: boolean;
-    code?: boolean;
-    text: string;
-};
-declare type CommentBody = {
-    version: 1;
-    content: CommentBodyBlockElement[];
-};
-
-declare type CommentData = {
-    type: "comment";
-    id: string;
-    threadId: string;
-    roomId: string;
-    userId: string;
-    createdAt: string;
-    editedAt?: string;
-} & ({
-    body: CommentBody;
-    deletedAt?: never;
-} | {
-    body?: never;
-    deletedAt: string;
-});
-
-declare type ThreadData<ThreadMetadata extends BaseMetadata = never> = {
-    type: "thread";
-    id: string;
-    roomId: string;
-    createdAt: string;
-    updatedAt?: string;
-    comments: CommentData[];
-    metadata: [ThreadMetadata] extends [never] ? Record<string, never> : ThreadMetadata;
-};
-
-declare type Options = {
-    serverEndpoint: string;
-};
-declare type CommentsApi<ThreadMetadata extends BaseMetadata> = {
-    getThreads(options: {
-        roomId: string;
-    }): Promise<ThreadData<ThreadMetadata>[]>;
-    createThread(options: {
-        roomId: string;
-        threadId: string;
-        commentId: string;
-        metadata: ThreadMetadata | undefined;
-        body: CommentBody;
-    }): Promise<ThreadData<ThreadMetadata>>;
-    editThreadMetadata(options: {
-        roomId: string;
-        metadata: Partial<ThreadMetadata>;
-        threadId: string;
-    }): Promise<ThreadData<ThreadMetadata>>;
-    createComment(options: {
-        roomId: string;
-        threadId: string;
-        commentId: string;
-        body: CommentBody;
-    }): Promise<CommentData>;
-    editComment(options: {
-        roomId: string;
-        threadId: string;
-        commentId: string;
-        body: CommentBody;
-    }): Promise<CommentData>;
-    deleteComment(options: {
-        roomId: string;
-        threadId: string;
-        commentId: string;
-    }): Promise<void>;
-};
-declare function createCommentsApi<ThreadMetadata extends BaseMetadata>(client: Client, { serverEndpoint }: Options): CommentsApi<ThreadMetadata>;
-
-declare type BaseUserInfo = {
-    name?: string;
-    avatar?: string;
-};
-
-declare function isCommentBodyMention(element: CommentBodyElement): element is CommentBodyMention;
-
 /**
  * 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
@@ -2299,4 +2285,4 @@ declare type EnsureJson<T> = [
     [K in keyof T]: EnsureJson<T[K]>;
 };
 
-export { AckOp, AsyncCache, AsyncState, AsyncStateError, AsyncStateInitial, AsyncStateLoading, AsyncStateResolved, AsyncStateSuccess, BaseAuthResult, BaseMetadata, BaseUserInfo, BaseUserMeta, BroadcastEventClientMsg, BroadcastOptions, BroadcastedEventServerMsg, Client, ClientMsg, ClientMsgCode, CommentBody, CommentBodyElement, CommentBodyMention, CommentBodyParagraph, CommentData, CommentsApi, CrdtType, CreateChildOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, CreateRootObjectOp, CustomAuthenticationResult, Delegates, DeleteCrdtOp, DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, EnsureJson, EventSource, FetchStorageClientMsg, FetchYDocClientMsg, History, IWebSocket, IWebSocketCloseEvent, IWebSocketEvent, IWebSocketInstance, IWebSocketMessageEvent, IdTuple, Immutable, InitialDocumentStateServerMsg, Json, JsonArray, JsonObject, JsonScalar, LegacyConnectionStatus, LiveList, LiveListUpdate, LiveMap, LiveMapUpdate, LiveNode, LiveObject, LiveObjectUpdate, LiveStructure, LostConnectionEvent, Lson, LsonObject, NodeMap, Op, OpCode, Others, ParentToChildNodeMap, PlainLson, PlainLsonFields, PlainLsonList, PlainLsonMap, PlainLsonObject, RealtimeClient, RejectedStorageOpServerMsg, Resolve, Room, RoomInitializers, RoomStateServerMsg, SerializedChild, SerializedCrdt, SerializedList, SerializedMap, SerializedObject, SerializedRegister, SerializedRootObject, ServerMsg, ServerMsgCode, SetParentKeyOp, Status, StorageStatus, StorageUpdate, ThreadData, ToImmutable, ToJson, UnsubscribeCallback, UpdateObjectOp, UpdatePresenceClientMsg, UpdatePresenceServerMsg, UpdateStorageClientMsg, UpdateStorageServerMsg, UpdateYDocClientMsg, User, UserJoinServerMsg, UserLeftServerMsg, WebsocketCloseCodes, asArrayWithLegacyMethods, asPos, assert, assertNever, b64decode, fancyConsole as console, createAsyncCache, createClient, createCommentsApi, deprecate, deprecateIf, detectDupes, errorIf, freeze, isChildCrdt, isCommentBodyMention, isJsonArray, isJsonObject, isJsonScalar, isPlainObject, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, nn, patchLiveObjectKey, shallow, throwUsageError, toPlainLson, tryParseJson, withTimeout };
+export { AckOp, AsyncCache, AsyncState, AsyncStateError, AsyncStateInitial, AsyncStateLoading, AsyncStateResolved, AsyncStateSuccess, BaseAuthResult, BaseMetadata, BaseUserMeta, BroadcastEventClientMsg, BroadcastOptions, BroadcastedEventServerMsg, Client, ClientMsg, ClientMsgCode, CommentBody, CommentBodyElement, CommentBodyMention, CommentBodyParagraph, CommentData, CommentsApi, CrdtType, CreateChildOp, CreateListOp, CreateMapOp, CreateObjectOp, CreateOp, CreateRegisterOp, CreateRootObjectOp, CustomAuthenticationResult, Delegates, DeleteCrdtOp, DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, EnsureJson, EventSource, FetchStorageClientMsg, FetchYDocClientMsg, History, IWebSocket, IWebSocketCloseEvent, IWebSocketEvent, IWebSocketInstance, IWebSocketMessageEvent, IdTuple, Immutable, InitialDocumentStateServerMsg, Json, JsonArray, JsonObject, JsonScalar, LegacyConnectionStatus, LiveList, LiveListUpdate, LiveMap, LiveMapUpdate, LiveNode, LiveObject, LiveObjectUpdate, LiveStructure, LostConnectionEvent, Lson, LsonObject, NodeMap, Op, OpCode, Others, ParentToChildNodeMap, PlainLson, PlainLsonFields, PlainLsonList, PlainLsonMap, PlainLsonObject, RejectedStorageOpServerMsg, Resolve, Room, RoomInitializers, RoomStateServerMsg, SerializedChild, SerializedCrdt, SerializedList, SerializedMap, SerializedObject, SerializedRegister, SerializedRootObject, ServerMsg, ServerMsgCode, SetParentKeyOp, Status, StorageStatus, StorageUpdate, ThreadData, ToImmutable, ToJson, UnsubscribeCallback, UpdateObjectOp, UpdatePresenceClientMsg, UpdatePresenceServerMsg, UpdateStorageClientMsg, UpdateStorageServerMsg, UpdateYDocClientMsg, User, UserJoinServerMsg, UserLeftServerMsg, WebsocketCloseCodes, asArrayWithLegacyMethods, asPos, assert, assertNever, b64decode, fancyConsole as console, createAsyncCache, createClient, createCommentsApi, deprecate, deprecateIf, detectDupes, errorIf, freeze, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isPlainObject, isRootCrdt, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, nn, patchLiveObjectKey, shallow, throwUsageError, toPlainLson, tryParseJson, withTimeout };