@liveblocks/core 2.12.1-emails1 → 2.12.1-test2

package/dist/index.d.ts

@@ -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:
@@ -28,6 +41,219 @@ 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 enum Permission {
+    Read = "room:read",
+    Write = "room:write",
+    PresenceWrite = "room:presence:write",
+    CommentsWrite = "comments:write",
+    CommentsRead = "comments:read"
+}
+
+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;
+    /**
+     * Returns the number of active subscribers.
+     */
+    count(): number;
+    /**
+     * Pauses event delivery until unpaused. Any .notify() calls made while
+     * paused will get buffered into memory and emitted later.
+     */
+    pause(): void;
+    /**
+     * Emits all in-memory buffered events, and unpauses. Any .notify() calls
+     * made after this will be synchronously delivered again.
+     */
+    unpause(): void;
+    /**
+     * Observable instance, which can be used to subscribe to this event source
+     * in a readonly fashion. Safe to publicly expose.
+     */
+    observable: Observable<T>;
+};
+/**
+ * makeEventSource allows you to generate a subscribe/notify pair of functions
+ * to make subscribing easy and to get notified about events.
+ *
+ * The events are anonymous, so you can use it to define events, like so:
+ *
+ *   const event1 = makeEventSource();
+ *   const event2 = makeEventSource();
+ *
+ *   event1.subscribe(foo);
+ *   event1.subscribe(bar);
+ *   event2.subscribe(qux);
+ *
+ *   // Unsubscription is pretty standard
+ *   const unsub = event2.subscribe(foo);
+ *   unsub();
+ *
+ *   event1.notify();  // Now foo and bar will get called
+ *   event2.notify();  // Now qux will get called (but foo will not, since it's unsubscribed)
+ *
+ */
+declare function makeEventSource<T>(): EventSource<T>;
+
+interface IWebSocketEvent {
+    type: string;
+}
+interface IWebSocketCloseEvent extends IWebSocketEvent {
+    readonly code: WebsocketCloseCodes;
+    readonly wasClean: boolean;
+    readonly reason: string;
+}
+interface IWebSocketMessageEvent extends IWebSocketEvent {
+    readonly data: string | Buffer | ArrayBuffer | readonly Buffer[];
+}
+interface IWebSocketInstance {
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    readonly CLOSING: number;
+    readonly CLOSED: number;
+    readonly readyState: number;
+    addEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
+    addEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
+    addEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
+    removeEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
+    removeEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
+    removeEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
+    close(): void;
+    send(data: string): void;
+}
+/**
+ * Either the browser-based WebSocket API or Node.js' WebSocket API (from the
+ * 'ws' package).
+ *
+ * This type defines the minimal WebSocket API that Liveblocks needs from
+ * a WebSocket implementation, and is a minimal subset of the browser-based
+ * WebSocket APIs and Node.js' WebSocket API so that both implementations are
+ * assignable to this type.
+ */
+interface IWebSocket {
+    new (address: string): IWebSocketInstance;
+}
+/**
+ * The following ranges will be respected by the client:
+ *
+ *   10xx: client will reauthorize (just like 41xx)
+ *   40xx: client will disconnect
+ *   41xx: client will reauthorize
+ *   42xx: client will retry without reauthorizing (currently not used)
+ *
+ */
+declare enum WebsocketCloseCodes {
+    /** Normal close of connection, the connection fulfilled its purpose. */
+    CLOSE_NORMAL = 1000,
+    /** Unexpected error happened with the network/infra level. In spirit akin to HTTP 503 */
+    CLOSE_ABNORMAL = 1006,
+    /** Unexpected error happened. In spirit akin to HTTP 500 */
+    UNEXPECTED_CONDITION = 1011,
+    /** Please back off for now, but try again in a few moments */
+    TRY_AGAIN_LATER = 1013,
+    /** Message wasn't understood, disconnect */
+    INVALID_MESSAGE_FORMAT = 4000,
+    /** Server refused to allow connection. Re-authorizing won't help. Disconnect. In spirit akin to HTTP 403 */
+    NOT_ALLOWED = 4001,
+    /** Unused */
+    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
+    /** Unused */
+    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
+    /** Unused */
+    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
+    /** Room is full, disconnect */
+    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
+    /** The room's ID was updated, disconnect */
+    ROOM_ID_UPDATED = 4006,
+    /** The server kicked the connection from the room. */
+    KICKED = 4100,
+    /** The auth token is expired, reauthorize to get a fresh one. In spirit akin to HTTP 401 */
+    TOKEN_EXPIRED = 4109,
+    /** Disconnect immediately */
+    CLOSE_WITHOUT_RETRY = 4999
+}
+
+/**
+ * Returns a human-readable status indicating the current connection status of
+ * a Room, as returned by `room.getStatus()`. Can be used to implement
+ * a connection status badge.
+ */
+declare type Status = "initial" | "connecting" | "connected" | "reconnecting" | "disconnected";
+/**
+ * Used to report about app-level reconnection issues.
+ *
+ * Normal (quick) reconnects won't be reported as a "lost connection". Instead,
+ * the application will only get an event if the reconnection attempts by the
+ * client are taking (much) longer than usual. Definitely a situation you want
+ * to inform your users about, for example, by throwing a toast message on
+ * screen, or show a "trying to reconnect" banner.
+ */
+declare type LostConnectionEvent = "lost" | "restored" | "failed";
+/**
+ * Arbitrary record that will be used as the authentication "authValue". It's the
+ * value that is returned by calling the authentication delegate, and will get
+ * passed to the connection factory delegate. This value will be remembered by
+ * the connection manager, but its value will not be interpreted, so it can be
+ * any value (except null).
+ */
+declare type BaseAuthResult = NonNullable<Json>;
+declare class LiveblocksError extends Error {
+    code: number;
+}
+declare type Delegates<T extends BaseAuthResult> = {
+    authenticate: () => Promise<T>;
+    createSocket: (authValue: T) => IWebSocketInstance;
+    canZombie: () => boolean;
+};
+
 declare enum OpCode {
     INIT = 0,
     SET_PARENT_KEY = 1,
@@ -206,77 +432,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;
 
@@ -554,6 +730,56 @@ declare type ToJson<T extends Lson | LsonObject> = T extends Json ? T : T extend
     [K in KS]: ToJson<V>;
 } : never;
 
+declare type LiveObjectUpdateDelta<O extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof O]?: UpdateDelta | undefined;
+};
+/**
+ * A LiveObject notification that is sent in-client to any subscribers whenever
+ * one or more of the entries inside the LiveObject instance have changed.
+ */
+declare type LiveObjectUpdates<TData extends LsonObject> = {
+    type: "LiveObject";
+    node: LiveObject<TData>;
+    updates: LiveObjectUpdateDelta<TData>;
+};
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+declare class LiveObject<O extends LsonObject> extends AbstractCrdt {
+    constructor(obj?: O);
+    /**
+     * Transform the LiveObject into a javascript object
+     */
+    toObject(): O;
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
+    set<TKey extends keyof O>(key: TKey, value: O[TKey]): void;
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
+    get<TKey extends keyof O>(key: TKey): O[TKey];
+    /**
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
+     */
+    delete(key: keyof O): void;
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param patch The object used to overrides properties
+     */
+    update(patch: Partial<O>): void;
+    toImmutable(): ToImmutable<O>;
+    clone(): LiveObject<O>;
+}
+
 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];
 };
@@ -620,31 +846,6 @@ declare type BaseRoomInfo = {
     url?: 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 type BaseMetadata = Record<string, string | boolean | number | undefined>;
 declare type CommentReaction = {
     emoji: string;
@@ -812,301 +1013,62 @@ declare global {
 }
 declare type ExtendableTypes = "Presence" | "Storage" | "UserMeta" | "RoomEvent" | "ThreadMetadata" | "RoomInfo" | "ActivitiesData";
 declare type MakeErrorString<K extends ExtendableTypes, Reason extends string = "does not match its requirements"> = `The type you provided for '${K}' ${Reason}. To learn how to fix this, see https://liveblocks.io/docs/errors/${K}`;
-declare type GetOverride<K extends ExtendableTypes, B, Reason extends string = "does not match its requirements"> = GetOverrideOrErrorValue<K, B, MakeErrorString<K, Reason>>;
-declare type GetOverrideOrErrorValue<K extends ExtendableTypes, B, ErrorType> = unknown extends Liveblocks[K] ? B : Liveblocks[K] extends B ? Liveblocks[K] : ErrorType;
-declare type DP = GetOverride<"Presence", JsonObject, "is not a valid JSON object">;
-declare type DS = GetOverride<"Storage", LsonObject, "is not a valid LSON value">;
-declare type DU = GetOverrideOrErrorValue<"UserMeta", BaseUserMeta, Record<"id" | "info", MakeErrorString<"UserMeta">>>;
-declare type DE = GetOverride<"RoomEvent", Json, "is not a valid JSON value">;
-declare type DM = GetOverride<"ThreadMetadata", BaseMetadata>;
-declare type DRI = GetOverride<"RoomInfo", BaseRoomInfo>;
-declare type DAD = GetOverrideOrErrorValue<"ActivitiesData", BaseActivitiesData, {
-    [K in keyof Liveblocks["ActivitiesData"]]: "At least one of the custom notification kinds you provided for 'ActivitiesData' does not match its requirements. To learn how to fix this, see https://liveblocks.io/docs/errors/ActivitiesData";
-}>;
-declare type KDAD = keyof DAD extends `$${string}` ? keyof DAD : "Custom notification kinds must start with '$' but your custom 'ActivitiesData' type contains at least one kind which doesn't. To learn how to fix this, see https://liveblocks.io/docs/errors/ActivitiesData";
-
-/**
- * Use this symbol to brand an object property as internal.
- *
- * @example
- * Object.defineProperty(
- *   {
- *     public,
- *     [kInternal]: {
- *       private
- *     },
- *   },
- *   kInternal,
- *   {
- *     enumerable: false,
- *   }
- * );
- */
-declare const kInternal: unique symbol;
-
-declare type RenameDataField<T, TFieldName extends string> = T extends any ? {
-    [K in keyof T as K extends "data" ? TFieldName : K]: T[K];
-} : never;
-declare type AsyncLoading<F extends string = "data"> = RenameDataField<{
-    readonly isLoading: true;
-    readonly data?: never;
-    readonly error?: never;
-}, F>;
-declare type AsyncSuccess<T, F extends string = "data"> = RenameDataField<{
-    readonly isLoading: false;
-    readonly data: T;
-    readonly error?: never;
-}, F>;
-declare type AsyncError<F extends string = "data"> = RenameDataField<{
-    readonly isLoading: false;
-    readonly data?: never;
-    readonly error: Error;
-}, F>;
-declare type AsyncResult<T, F extends string = "data"> = AsyncLoading<F> | AsyncSuccess<T, F> | AsyncError<F>;
-
-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;
-    /**
-     * 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>;
-
-declare type BatchStore<O, I> = Observable<void> & {
-    get: (input: I) => Promise<void>;
-    getState: (input: I) => AsyncResult<O> | undefined;
-    invalidate: (inputs?: I[]) => void;
-};
-
-/**
- * A Store is just a mini Zustand store.
- */
-declare type Store<T> = {
-    get: () => Readonly<T>;
-    set: (callback: (currentState: Readonly<T>) => Readonly<T>) => void;
-    subscribe: (callback: () => void) => () => void;
-    batch: (callback: () => void) => void;
-};
-/**
- * Create a store for an immutable state. Close to Zustand's vanilla store conceptually but with less features.
- */
-declare function createStore<T>(initialState: T): Store<T>;
-
-/**
- * Back-port of TypeScript 5.4's built-in NoInfer utility type.
- * See https://stackoverflow.com/a/56688073/148872
- */
-declare type NoInfr<A> = [A][A extends any ? 0 : 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;
-};
-
-interface IWebSocketEvent {
-    type: string;
-}
-interface IWebSocketCloseEvent extends IWebSocketEvent {
-    readonly code: WebsocketCloseCodes;
-    readonly wasClean: boolean;
-    readonly reason: string;
-}
-interface IWebSocketMessageEvent extends IWebSocketEvent {
-    readonly data: string | Buffer | ArrayBuffer | readonly Buffer[];
-}
-interface IWebSocketInstance {
-    readonly CONNECTING: number;
-    readonly OPEN: number;
-    readonly CLOSING: number;
-    readonly CLOSED: number;
-    readonly readyState: number;
-    addEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
-    addEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
-    addEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
-    removeEventListener(type: "close", listener: (this: IWebSocketInstance, ev: IWebSocketCloseEvent) => unknown): void;
-    removeEventListener(type: "message", listener: (this: IWebSocketInstance, ev: IWebSocketMessageEvent) => unknown): void;
-    removeEventListener(type: "open" | "error", listener: (this: IWebSocketInstance, ev: IWebSocketEvent) => unknown): void;
-    close(): void;
-    send(data: string): void;
-}
-/**
- * Either the browser-based WebSocket API or Node.js' WebSocket API (from the
- * 'ws' package).
- *
- * This type defines the minimal WebSocket API that Liveblocks needs from
- * a WebSocket implementation, and is a minimal subset of the browser-based
- * WebSocket APIs and Node.js' WebSocket API so that both implementations are
- * assignable to this type.
- */
-interface IWebSocket {
-    new (address: string): IWebSocketInstance;
-}
-/**
- * The following ranges will be respected by the client:
- *
- *   10xx: client will reauthorize (just like 41xx)
- *   40xx: client will disconnect
- *   41xx: client will reauthorize
- *   42xx: client will retry without reauthorizing (currently not used)
- *
- */
-declare enum WebsocketCloseCodes {
-    /** Normal close of connection, the connection fulfilled its purpose. */
-    CLOSE_NORMAL = 1000,
-    /** Unexpected error happened with the network/infra level. In spirit akin to HTTP 503 */
-    CLOSE_ABNORMAL = 1006,
-    /** Unexpected error happened. In spirit akin to HTTP 500 */
-    UNEXPECTED_CONDITION = 1011,
-    /** Please back off for now, but try again in a few moments */
-    TRY_AGAIN_LATER = 1013,
-    /** Message wasn't understood, disconnect */
-    INVALID_MESSAGE_FORMAT = 4000,
-    /** Server refused to allow connection. Re-authorizing won't help. Disconnect. In spirit akin to HTTP 403 */
-    NOT_ALLOWED = 4001,
-    /** Unused */
-    MAX_NUMBER_OF_MESSAGES_PER_SECONDS = 4002,
-    /** Unused */
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS = 4003,
-    /** Unused */
-    MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004,
-    /** Room is full, disconnect */
-    MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005,
-    /** The room's ID was updated, disconnect */
-    ROOM_ID_UPDATED = 4006,
-    /** The server kicked the connection from the room. */
-    KICKED = 4100,
-    /** The auth token is expired, reauthorize to get a fresh one. In spirit akin to HTTP 401 */
-    TOKEN_EXPIRED = 4109,
-    /** Disconnect immediately */
-    CLOSE_WITHOUT_RETRY = 4999
-}
+declare type GetOverride<K extends ExtendableTypes, B, Reason extends string = "does not match its requirements"> = GetOverrideOrErrorValue<K, B, MakeErrorString<K, Reason>>;
+declare type GetOverrideOrErrorValue<K extends ExtendableTypes, B, ErrorType> = unknown extends Liveblocks[K] ? B : Liveblocks[K] extends B ? Liveblocks[K] : ErrorType;
+declare type DP = GetOverride<"Presence", JsonObject, "is not a valid JSON object">;
+declare type DS = GetOverride<"Storage", LsonObject, "is not a valid LSON value">;
+declare type DU = GetOverrideOrErrorValue<"UserMeta", BaseUserMeta, Record<"id" | "info", MakeErrorString<"UserMeta">>>;
+declare type DE = GetOverride<"RoomEvent", Json, "is not a valid JSON value">;
+declare type DM = GetOverride<"ThreadMetadata", BaseMetadata>;
+declare type DRI = GetOverride<"RoomInfo", BaseRoomInfo>;
+declare type DAD = GetOverrideOrErrorValue<"ActivitiesData", BaseActivitiesData, {
+    [K in keyof Liveblocks["ActivitiesData"]]: "At least one of the custom notification kinds you provided for 'ActivitiesData' does not match its requirements. To learn how to fix this, see https://liveblocks.io/docs/errors/ActivitiesData";
+}>;
+declare type KDAD = keyof DAD extends `$${string}` ? keyof DAD : "Custom notification kinds must start with '$' but your custom 'ActivitiesData' type contains at least one kind which doesn't. To learn how to fix this, see https://liveblocks.io/docs/errors/ActivitiesData";
 
 /**
- * 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.
- */
-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).
+ * @example
+ * Object.defineProperty(
+ *   {
+ *     public,
+ *     [kInternal]: {
+ *       private
+ *     },
+ *   },
+ *   kInternal,
+ *   {
+ *     enumerable: false,
+ *   }
+ * );
  */
-declare type BaseAuthResult = NonNullable<Json>;
-declare class LiveblocksError extends Error {
-    code: number;
-}
-declare type Delegates<T extends BaseAuthResult> = {
-    authenticate: () => Promise<T>;
-    createSocket: (authValue: T) => IWebSocketInstance;
-    canZombie: () => boolean;
+declare const kInternal: unique symbol;
+
+declare type RenameDataField<T, TFieldName extends string> = T extends any ? {
+    [K in keyof T as K extends "data" ? TFieldName : K]: T[K];
+} : never;
+declare type AsyncLoading<F extends string = "data"> = RenameDataField<{
+    readonly isLoading: true;
+    readonly data?: never;
+    readonly error?: never;
+}, F>;
+declare type AsyncSuccess<T, F extends string = "data"> = RenameDataField<{
+    readonly isLoading: false;
+    readonly data: T;
+    readonly error?: never;
+}, F>;
+declare type AsyncError<F extends string = "data"> = RenameDataField<{
+    readonly isLoading: false;
+    readonly data?: never;
+    readonly error: Error;
+}, F>;
+declare type AsyncResult<T, F extends string = "data"> = AsyncLoading<F> | AsyncSuccess<T, F> | AsyncError<F>;
+
+declare type BatchStore<O, I> = Observable<void> & {
+    get: (input: I) => Promise<void>;
+    getState: (input: I) => AsyncResult<O> | undefined;
+    invalidate: (inputs?: I[]) => void;
 };
 
 declare enum ClientMsgCode {
@@ -1500,6 +1462,32 @@ 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 };
 }
 
+/**
+ * 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];
+};
+
 /**
  * Represents a user connected in a room. Treated as immutable.
  */
@@ -2064,6 +2052,7 @@ declare type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extend
         inboxNotifications: InboxNotificationData[];
         requestedAt: Date;
         nextCursor: string | null;
+        permissionHints: Record<string, Permission[]>;
     }>;
     /**
      * Returns the updated and deleted threads and their associated inbox notifications since the requested date.
@@ -2083,6 +2072,7 @@ declare type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extend
             deleted: InboxNotificationDeleteInfo[];
         };
         requestedAt: Date;
+        permissionHints: Record<string, Permission[]>;
     }>;
     /**
      * Returns a thread and the associated inbox notification if it exists.
@@ -2351,24 +2341,261 @@ declare type OptionalTupleUnless<C, T extends any[]> = Record<string, never> ext
     C
 ] extends [never] ? OptionalTuple<T> : T;
 
-declare type GetInboxNotificationsOptions = {
-    cursor?: string;
-};
-declare type GetInboxNotificationsSinceOptions = {
-    since: Date;
-    signal?: AbortSignal;
-};
-declare type GetUserThreadsOptions<M extends BaseMetadata> = {
-    cursor?: string;
-    query?: {
-        resolved?: boolean;
-        metadata?: Partial<QueryMetadata<M>>;
-    };
-};
-declare type GetUserThreadsSinceOptions = {
-    since: Date;
-    signal?: AbortSignal;
+interface RoomHttpApi<M extends BaseMetadata> {
+    getThreads(options: {
+        roomId: string;
+        cursor?: string;
+        query?: {
+            resolved?: boolean;
+            metadata?: Partial<QueryMetadata<M>>;
+        };
+    }): Promise<{
+        threads: ThreadData<M>[];
+        inboxNotifications: InboxNotificationData[];
+        requestedAt: Date;
+        nextCursor: string | null;
+        permissionHints: Record<string, Permission[]>;
+    }>;
+    getThreadsSince(options: {
+        roomId: string;
+        since: Date;
+        signal?: AbortSignal;
+    }): Promise<{
+        threads: {
+            updated: ThreadData<M>[];
+            deleted: ThreadDeleteInfo[];
+        };
+        inboxNotifications: {
+            updated: InboxNotificationData[];
+            deleted: InboxNotificationDeleteInfo[];
+        };
+        requestedAt: Date;
+        permissionHints: Record<string, Permission[]>;
+    }>;
+    createThread({ roomId, metadata, body, commentId, threadId, attachmentIds, }: {
+        roomId: string;
+        threadId?: string;
+        commentId?: string;
+        metadata: M | undefined;
+        body: CommentBody;
+        attachmentIds?: string[];
+    }): Promise<ThreadData<M>>;
+    getThread(options: {
+        roomId: string;
+        threadId: string;
+    }): Promise<{
+        thread?: ThreadData<M>;
+        inboxNotification?: InboxNotificationData;
+    }>;
+    deleteThread({ roomId, threadId, }: {
+        roomId: string;
+        threadId: string;
+    }): Promise<void>;
+    editThreadMetadata({ roomId, metadata, threadId, }: {
+        roomId: string;
+        metadata: Patchable<M>;
+        threadId: string;
+    }): Promise<M>;
+    createComment({ roomId, threadId, commentId, body, attachmentIds, }: {
+        roomId: string;
+        threadId: string;
+        commentId?: string;
+        body: CommentBody;
+        attachmentIds?: string[];
+    }): Promise<CommentData>;
+    editComment({ roomId, threadId, commentId, body, attachmentIds, }: {
+        roomId: string;
+        threadId: string;
+        commentId: string;
+        body: CommentBody;
+        attachmentIds?: string[];
+    }): Promise<CommentData>;
+    deleteComment({ roomId, threadId, commentId, }: {
+        roomId: string;
+        threadId: string;
+        commentId: string;
+    }): Promise<void>;
+    addReaction({ roomId, threadId, commentId, emoji, }: {
+        roomId: string;
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }): Promise<CommentUserReaction>;
+    removeReaction({ roomId, threadId, commentId, emoji, }: {
+        roomId: string;
+        threadId: string;
+        commentId: string;
+        emoji: string;
+    }): Promise<void>;
+    markThreadAsResolved({ roomId, threadId, }: {
+        roomId: string;
+        threadId: string;
+    }): Promise<void>;
+    markThreadAsUnresolved({ roomId, threadId, }: {
+        roomId: string;
+        threadId: string;
+    }): Promise<void>;
+    markRoomInboxNotificationAsRead({ roomId, inboxNotificationId, }: {
+        roomId: string;
+        inboxNotificationId: string;
+    }): Promise<string>;
+    getNotificationSettings({ roomId, signal, }: {
+        roomId: string;
+        signal?: AbortSignal;
+    }): Promise<RoomNotificationSettings>;
+    updateNotificationSettings({ roomId, settings, }: {
+        roomId: string;
+        settings: Partial<RoomNotificationSettings>;
+    }): Promise<RoomNotificationSettings>;
+    getAttachmentUrl(options: {
+        roomId: string;
+        attachmentId: string;
+    }): Promise<string>;
+    uploadAttachment({ roomId, attachment, signal, }: {
+        roomId: string;
+        attachment: CommentLocalAttachment;
+        signal?: AbortSignal;
+    }): Promise<CommentAttachment>;
+    getOrCreateAttachmentUrlsStore(roomId: string): BatchStore<string, string>;
+    createTextMention({ roomId, userId, mentionId, }: {
+        roomId: string;
+        userId: string;
+        mentionId: string;
+    }): Promise<void>;
+    deleteTextMention({ roomId, mentionId, }: {
+        roomId: string;
+        mentionId: string;
+    }): Promise<void>;
+    getTextVersion({ roomId, versionId, }: {
+        roomId: string;
+        versionId: string;
+    }): Promise<Response>;
+    createTextVersion({ roomId }: {
+        roomId: string;
+    }): Promise<void>;
+    reportTextEditor({ roomId, type, rootKey, }: {
+        roomId: string;
+        type: TextEditorType;
+        rootKey: string;
+    }): Promise<void>;
+    listTextVersions({ roomId }: {
+        roomId: string;
+    }): Promise<{
+        versions: {
+            type: "historyVersion";
+            kind: "yjs";
+            id: string;
+            authors: {
+                id: string;
+            }[];
+            createdAt: Date;
+        }[];
+        requestedAt: Date;
+    }>;
+    listTextVersionsSince({ roomId, since, signal, }: {
+        roomId: string;
+        since: Date;
+        signal?: AbortSignal;
+    }): Promise<{
+        versions: {
+            type: "historyVersion";
+            kind: "yjs";
+            id: string;
+            authors: {
+                id: string;
+            }[];
+            createdAt: Date;
+        }[];
+        requestedAt: Date;
+    }>;
+    streamStorage(options: {
+        roomId: string;
+    }): Promise<IdTuple<SerializedCrdt>[]>;
+    sendMessages<P extends JsonObject, E extends Json>(options: {
+        roomId: string;
+        nonce: string | undefined;
+        messages: ClientMsg<P, E>[];
+    }): Promise<Response>;
+}
+interface NotificationHttpApi<M extends BaseMetadata> {
+    getInboxNotifications(options?: {
+        cursor?: string;
+    }): Promise<{
+        inboxNotifications: InboxNotificationData[];
+        threads: ThreadData<M>[];
+        nextCursor: string | null;
+        requestedAt: Date;
+    }>;
+    getInboxNotificationsSince(options: {
+        since: Date;
+        signal?: AbortSignal;
+    }): Promise<{
+        inboxNotifications: {
+            updated: InboxNotificationData[];
+            deleted: InboxNotificationDeleteInfo[];
+        };
+        threads: {
+            updated: ThreadData<M>[];
+            deleted: ThreadDeleteInfo[];
+        };
+        requestedAt: Date;
+    }>;
+    getUnreadInboxNotificationsCount(): Promise<number>;
+    markAllInboxNotificationsAsRead(): Promise<void>;
+    markInboxNotificationAsRead(inboxNotificationId: string): Promise<void>;
+    deleteAllInboxNotifications(): Promise<void>;
+    deleteInboxNotification(inboxNotificationId: string): Promise<void>;
+}
+interface LiveblocksHttpApi<M extends BaseMetadata> extends RoomHttpApi<M>, NotificationHttpApi<M> {
+    getUserThreads_experimental(options?: {
+        cursor?: string;
+        query?: {
+            resolved?: boolean;
+            metadata?: Partial<QueryMetadata<M>>;
+        };
+    }): Promise<{
+        threads: ThreadData<M>[];
+        inboxNotifications: InboxNotificationData[];
+        nextCursor: string | null;
+        requestedAt: Date;
+        permissionHints: Record<string, Permission[]>;
+    }>;
+    getUserThreadsSince_experimental(options: {
+        since: Date;
+        signal?: AbortSignal;
+    }): Promise<{
+        inboxNotifications: {
+            updated: InboxNotificationData[];
+            deleted: InboxNotificationDeleteInfo[];
+        };
+        threads: {
+            updated: ThreadData<M>[];
+            deleted: ThreadDeleteInfo[];
+        };
+        requestedAt: Date;
+        permissionHints: Record<string, Permission[]>;
+    }>;
+}
+
+/**
+ * A Store is just a mini Zustand store.
+ */
+declare type Store<T> = {
+    get: () => Readonly<T>;
+    set: (callback: (currentState: Readonly<T>) => Readonly<T>) => void;
+    subscribe: (callback: () => void) => () => void;
+    batch: (callback: () => void) => void;
 };
+/**
+ * Create a store for an immutable state. Close to Zustand's vanilla store conceptually but with less features.
+ */
+declare function createStore<T>(initialState: T): Store<T>;
+
+/**
+ * Back-port of TypeScript 5.4's built-in NoInfer utility type.
+ * See https://stackoverflow.com/a/56688073/148872
+ */
+declare type NoInfr<A> = [A][A extends any ? 0 : never];
 
 declare type OptionalPromise<T> = T | Promise<T>;
 
@@ -2441,29 +2668,13 @@ declare type InternalSyncStatus = SyncStatus | "has-local-changes";
  * will probably happen if you do.
  */
 declare type PrivateClientApi<U extends BaseUserMeta, M extends BaseMetadata> = {
-    readonly currentUserIdStore: Store<string | null>;
+    readonly currentUserIdStore: Store<string | undefined>;
     readonly mentionSuggestionsCache: Map<string, string[]>;
     readonly resolveMentionSuggestions: ClientOptions<U>["resolveMentionSuggestions"];
     readonly usersStore: BatchStore<U["info"] | undefined, string>;
     readonly roomsInfoStore: BatchStore<DRI | undefined, string>;
     readonly getRoomIds: () => string[];
-    readonly getUserThreads_experimental: (options: GetUserThreadsOptions<M>) => Promise<{
-        threads: ThreadData<M>[];
-        inboxNotifications: InboxNotificationData[];
-        nextCursor: string | null;
-        requestedAt: Date;
-    }>;
-    readonly getUserThreadsSince_experimental: (options: GetUserThreadsSinceOptions) => Promise<{
-        inboxNotifications: {
-            updated: InboxNotificationData[];
-            deleted: InboxNotificationDeleteInfo[];
-        };
-        threads: {
-            updated: ThreadData<M>[];
-            deleted: ThreadDeleteInfo[];
-        };
-        requestedAt: Date;
-    }>;
+    readonly httpClient: LiveblocksHttpApi<M>;
     as<M2 extends BaseMetadata>(): Client<U, M2>;
     createSyncSource(): SyncSource;
 };
@@ -2485,7 +2696,9 @@ declare type NotificationsApi<M extends BaseMetadata> = {
      * const data = await client.getInboxNotifications();  // Fetch initial page (of 20 inbox notifications)
      * const data = await client.getInboxNotifications({ cursor: nextCursor });  // Fetch next page (= next 20 inbox notifications)
      */
-    getInboxNotifications(options?: GetInboxNotificationsOptions): Promise<{
+    getInboxNotifications(options?: {
+        cursor?: string;
+    }): Promise<{
         inboxNotifications: InboxNotificationData[];
         threads: ThreadData<M>[];
         nextCursor: string | null;
@@ -2510,7 +2723,10 @@ declare type NotificationsApi<M extends BaseMetadata> = {
      *   requestedAt,
      * } = await client.getInboxNotificationsSince({ since: result.requestedAt }});
      */
-    getInboxNotificationsSince(options: GetInboxNotificationsSinceOptions): Promise<{
+    getInboxNotificationsSince(options: {
+        since: Date;
+        signal?: AbortSignal;
+    }): Promise<{
         inboxNotifications: {
             updated: InboxNotificationData[];
             deleted: InboxNotificationDeleteInfo[];
@@ -2962,6 +3178,7 @@ declare function Promise_withResolvers<T>(): {
 
 declare function createThreadId(): string;
 declare function createCommentId(): string;
+declare function createCommentAttachmentId(): string;
 declare function createInboxNotificationId(): string;
 
 /**
@@ -3427,4 +3644,4 @@ declare const CommentsApiError: typeof HttpError;
 /** @deprecated Use HttpError instead. */
 declare const NotificationsApiError: typeof HttpError;
 
-export { type AckOp, type ActivityData, type AsyncError, type AsyncLoading, type AsyncResult, type AsyncSuccess, type BaseActivitiesData, type BaseAuthResult, type BaseMetadata, type BaseRoomInfo, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type Client, type ClientMsg, ClientMsgCode, type ClientOptions, type CommentAttachment, type CommentBody, type CommentBodyBlockElement, type CommentBodyElement, type CommentBodyInlineElement, type CommentBodyLink, type CommentBodyLinkElementArgs, type CommentBodyMention, type CommentBodyMentionElementArgs, type CommentBodyParagraph, type CommentBodyParagraphElementArgs, type CommentBodyText, type CommentBodyTextElementArgs, type CommentData, type CommentDataPlain, type CommentLocalAttachment, type CommentMixedAttachment, type CommentReaction, type CommentUserReaction, type CommentUserReactionPlain, CommentsApiError, type CommentsEventServerMsg, CrdtType, type CreateListOp, type CreateMapOp, type CreateObjectOp, type CreateOp, type CreateRegisterOp, type CustomAuthenticationResult, type DAD, type DE, type DM, type DP, type DRI, type DS, type DU, type Delegates, type DeleteCrdtOp, type DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, type DistributiveOmit, type EnsureJson, type EnterOptions, type EventSource, type FetchStorageClientMsg, type FetchYDocClientMsg, type GetThreadsOptions, type GetUserThreadsOptions, type History, type HistoryVersion, HttpError, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IYjsProvider, type IdTuple, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type InboxNotificationTextMentionData, type InboxNotificationTextMentionDataPlain, type InboxNotificationThreadData, type InboxNotificationThreadDataPlain, type InitialDocumentStateServerMsg, type Json, type JsonArray, type JsonObject, type JsonScalar, type KDAD, LiveList, type LiveListUpdate, LiveMap, type LiveMapUpdate, type LiveNode, LiveObject, type LiveObjectUpdate, type LiveStructure, LiveblocksError, type LostConnectionEvent, type Lson, type LsonObject, type NoInfr, type NodeMap, NotificationsApiError, type Observable, type Op, OpCode, type OpaqueClient, type OpaqueRoom, type OptionalPromise, type OptionalTupleUnless, type OthersEvent, type ParentToChildNodeMap, type PartialUnless, type Patchable, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type Poller, type PrivateClientApi, type PrivateRoomApi, Promise_withResolvers, type QueryMetadata, type QueryParams, type RejectedStorageOpServerMsg, type Resolve, type ResolveMentionSuggestionsArgs, type ResolveRoomsInfoArgs, type ResolveUsersArgs, type Room, type RoomEventMessage, type RoomNotificationSettings, type RoomStateServerMsg, type SerializedChild, type SerializedCrdt, type SerializedList, type SerializedMap, type SerializedObject, type SerializedRegister, type SerializedRootObject, type ServerMsg, ServerMsgCode, type SetParentKeyOp, SortedList, type Status, type StorageStatus, type StorageUpdate, type Store, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, type SyncSource, type SyncStatus, TextEditorType, type ThreadData, type ThreadDataPlain, type ThreadDataWithDeleteInfo, type ThreadDeleteInfo, type ToImmutable, type ToJson, type URLSafeString, type UnsubscribeCallback, type UpdateObjectOp, type UpdatePresenceClientMsg, type UpdatePresenceServerMsg, type UpdateStorageClientMsg, type UpdateStorageServerMsg, type UpdateYDocClientMsg, type UploadAttachmentOptions, type User, type UserJoinServerMsg, type UserLeftServerMsg, WebsocketCloseCodes, type YDocUpdateServerMsg, type YjsSyncStatus, ackOp, asPos, assert, assertNever, autoRetry, b64decode, chunk, cloneLson, compactObject, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToInboxNotificationData, convertToThreadData, createClient, createCommentId, createInboxNotificationId, createStore, createThreadId, deprecate, deprecateIf, detectDupes, errorIf, freeze, generateCommentUrl, getMentionedIdsFromCommentBody, html, htmlSafe, isChildCrdt, isCommentBodyLink, isCommentBodyMention, isCommentBodyText, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, kInternal, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, mapValues, memoizeOnSuccess, nanoid, nn, objectToQuery, patchLiveObjectKey, raise, resolveUsersInCommentBody, shallow, stringify, stringifyCommentBody, throwUsageError, toAbsoluteUrl, toPlainLson, tryParseJson, url, urljoin, wait, withTimeout };
+export { type AckOp, type ActivityData, type AsyncError, type AsyncLoading, type AsyncResult, type AsyncSuccess, type BaseActivitiesData, type BaseAuthResult, type BaseMetadata, type BaseRoomInfo, type BaseUserMeta, type Brand, type BroadcastEventClientMsg, type BroadcastOptions, type BroadcastedEventServerMsg, type Client, type ClientMsg, ClientMsgCode, type ClientOptions, type CommentAttachment, type CommentBody, type CommentBodyBlockElement, type CommentBodyElement, type CommentBodyInlineElement, type CommentBodyLink, type CommentBodyLinkElementArgs, type CommentBodyMention, type CommentBodyMentionElementArgs, type CommentBodyParagraph, type CommentBodyParagraphElementArgs, type CommentBodyText, type CommentBodyTextElementArgs, type CommentData, type CommentDataPlain, type CommentLocalAttachment, type CommentMixedAttachment, type CommentReaction, type CommentUserReaction, type CommentUserReactionPlain, CommentsApiError, type CommentsEventServerMsg, CrdtType, type CreateListOp, type CreateMapOp, type CreateObjectOp, type CreateOp, type CreateRegisterOp, type CustomAuthenticationResult, type DAD, type DE, type DM, type DP, type DRI, type DS, type DU, type Delegates, type DeleteCrdtOp, type DeleteObjectKeyOp, DevToolsTreeNode as DevTools, protocol as DevToolsMsg, type DistributiveOmit, type EnsureJson, type EnterOptions, type EventSource, type FetchStorageClientMsg, type FetchYDocClientMsg, type GetThreadsOptions, type History, type HistoryVersion, HttpError, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IYjsProvider, type IdTuple, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type InboxNotificationTextMentionData, type InboxNotificationTextMentionDataPlain, type InboxNotificationThreadData, type InboxNotificationThreadDataPlain, type InitialDocumentStateServerMsg, type Json, type JsonArray, type JsonObject, type JsonScalar, type KDAD, LiveList, type LiveListUpdate, LiveMap, type LiveMapUpdate, type LiveNode, LiveObject, type LiveObjectUpdate, type LiveStructure, LiveblocksError, type LostConnectionEvent, type Lson, type LsonObject, type NoInfr, type NodeMap, NotificationsApiError, type Observable, type Op, OpCode, type OpaqueClient, type OpaqueRoom, type OptionalPromise, type OptionalTupleUnless, type OthersEvent, type ParentToChildNodeMap, type PartialUnless, type Patchable, Permission, type PlainLson, type PlainLsonFields, type PlainLsonList, type PlainLsonMap, type PlainLsonObject, type Poller, type PrivateClientApi, type PrivateRoomApi, Promise_withResolvers, type QueryMetadata, type QueryParams, type RejectedStorageOpServerMsg, type Resolve, type ResolveMentionSuggestionsArgs, type ResolveRoomsInfoArgs, type ResolveUsersArgs, type Room, type RoomEventMessage, type RoomNotificationSettings, type RoomStateServerMsg, type SerializedChild, type SerializedCrdt, type SerializedList, type SerializedMap, type SerializedObject, type SerializedRegister, type SerializedRootObject, type ServerMsg, ServerMsgCode, type SetParentKeyOp, SortedList, type Status, type StorageStatus, type StorageUpdate, type Store, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, type SyncSource, type SyncStatus, TextEditorType, type ThreadData, type ThreadDataPlain, type ThreadDataWithDeleteInfo, type ThreadDeleteInfo, type ToImmutable, type ToJson, type URLSafeString, type UnsubscribeCallback, type UpdateObjectOp, type UpdatePresenceClientMsg, type UpdatePresenceServerMsg, type UpdateStorageClientMsg, type UpdateStorageServerMsg, type UpdateYDocClientMsg, type UploadAttachmentOptions, type User, type UserJoinServerMsg, type UserLeftServerMsg, WebsocketCloseCodes, type YDocUpdateServerMsg, type YjsSyncStatus, ackOp, asPos, assert, assertNever, autoRetry, b64decode, chunk, cloneLson, compactObject, fancyConsole as console, convertToCommentData, convertToCommentUserReaction, convertToInboxNotificationData, convertToThreadData, createClient, createCommentAttachmentId, createCommentId, createInboxNotificationId, createStore, createThreadId, deprecate, deprecateIf, detectDupes, errorIf, freeze, generateCommentUrl, getMentionedIdsFromCommentBody, html, htmlSafe, isChildCrdt, isCommentBodyLink, isCommentBodyMention, isCommentBodyText, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, kInternal, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, mapValues, memoizeOnSuccess, nanoid, nn, objectToQuery, patchLiveObjectKey, raise, resolveUsersInCommentBody, shallow, stringify, stringifyCommentBody, throwUsageError, toAbsoluteUrl, toPlainLson, tryParseJson, url, urljoin, wait, withTimeout };