@liveblocks/core 2.8.3-tiptap1 → 2.9.0-rc1

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:
@@ -41,211 +28,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;
 
-/**
- * Represents some constraints for user info. Basically read this as: "any JSON
- * object is fine, but _if_ it has a name field, it _must_ be a string."
- * (Ditto for avatar.)
- */
-declare type IUserInfo = {
-    [key: string]: Json | undefined;
-    name?: string;
-    avatar?: string;
-};
-/**
- * This type is used by clients to define the metadata for a user.
- */
-declare type BaseUserMeta = {
-    /**
-     * The id of the user that has been set in the authentication endpoint.
-     * Useful to get additional information about the connected user.
-     */
-    id?: string;
-    /**
-     * Additional user information that has been set in the authentication endpoint.
-     */
-    info?: IUserInfo;
-};
-
-declare type Callback<T> = (event: T) => void;
-declare type UnsubscribeCallback = () => void;
-declare type Observable<T> = {
-    /**
-     * Register a callback function to be called whenever the event source emits
-     * an event.
-     */
-    subscribe(callback: Callback<T>): UnsubscribeCallback;
-    /**
-     * Register a one-time callback function to be called whenever the event
-     * source emits an event. After the event fires, the callback is
-     * auto-unsubscribed.
-     */
-    subscribeOnce(callback: Callback<T>): UnsubscribeCallback;
-    /**
-     * Returns a promise that will resolve when an event is emitted by this
-     * event source. Optionally, specify a predicate that has to match. The first
-     * event matching that predicate will then resolve the promise.
-     */
-    waitUntil(predicate?: (event: T) => boolean): Promise<T>;
-};
-declare type EventSource<T> = Observable<T> & {
-    /**
-     * Notify all subscribers about the event.
-     */
-    notify(event: T): void;
-    /**
-     * 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,
@@ -424,33 +206,83 @@ 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
- *   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 }
- *
+ * 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 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;
+declare type LiveObjectUpdates<TData extends LsonObject> = {
+    type: "LiveObject";
+    node: LiveObject<TData>;
+    updates: LiveObjectUpdateDelta<TData>;
+};
 /**
- * Returns PlainLson for a given Json or LiveStructure, suitable for calling the storage init api
+ * 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 function toPlainLson(lson: Lson): PlainLson;
-
-/**
- * A LiveMap notification that is sent in-client to any subscribers whenever
- * one or more of the values inside the LiveMap instance have changed.
+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
+ */
+declare function toPlainLson(lson: Lson): PlainLson;
+
+/**
+ * A LiveMap notification that is sent in-client to any subscribers whenever
+ * one or more of the values inside the LiveMap instance have changed.
  */
 declare type LiveMapUpdates<TKey extends string, TValue extends Lson> = {
     type: "LiveMap";
@@ -721,56 +553,6 @@ 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];
 };
@@ -837,6 +619,31 @@ 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;
@@ -954,111 +761,350 @@ declare type CommentUserReaction = {
 };
 declare type CommentUserReactionPlain = DateToString<CommentUserReaction>;
 /**
- * Represents a thread of comments.
+ * Represents a thread of comments.
+ */
+declare type ThreadData<M extends BaseMetadata = DM> = {
+    type: "thread";
+    id: string;
+    roomId: string;
+    createdAt: Date;
+    updatedAt?: Date;
+    comments: CommentData[];
+    metadata: M;
+    resolved: boolean;
+};
+interface ThreadDataWithDeleteInfo<M extends BaseMetadata = DM> extends ThreadData<M> {
+    deletedAt?: Date;
+}
+declare type ThreadDataPlain<M extends BaseMetadata> = Omit<DateToString<ThreadData<M>>, "comments" | "metadata"> & {
+    comments: CommentDataPlain[];
+    metadata: M;
+};
+declare type ThreadDeleteInfo = {
+    type: "deletedThread";
+    id: string;
+    roomId: string;
+    deletedAt: Date;
+};
+declare type StringOperators<T> = T | {
+    startsWith: string;
+};
+/**
+ * This type can be used to build a metadata query string (compatible
+ * with `@liveblocks/query-parser`) through a type-safe API.
+ *
+ * In addition to exact values (`:` in query string), it adds:
+ * - to strings:
+ *  - `startsWith` (`^` in query string)
+ */
+declare type QueryMetadata<M extends BaseMetadata> = {
+    [K in keyof M]: string extends M[K] ? StringOperators<M[K]> : M[K];
+};
+
+declare global {
+    /**
+     * Namespace for user-defined Liveblocks types.
+     */
+    export interface Liveblocks {
+        [key: string]: unknown;
+    }
+}
+declare type ExtendableTypes = "Presence" | "Storage" | "UserMeta" | "RoomEvent" | "ThreadMetadata" | "RoomInfo" | "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;
+};
+
+/**
+ * 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.
  */
-declare type ThreadData<M extends BaseMetadata = DM> = {
-    type: "thread";
-    id: string;
-    roomId: string;
-    createdAt: Date;
-    updatedAt?: Date;
-    comments: CommentData[];
-    metadata: M;
-    resolved: boolean;
-};
-interface ThreadDataWithDeleteInfo<M extends BaseMetadata = DM> extends ThreadData<M> {
-    deletedAt?: Date;
+interface IWebSocket {
+    new (address: string): IWebSocketInstance;
 }
-declare type ThreadDataPlain<M extends BaseMetadata> = Omit<DateToString<ThreadData<M>>, "comments" | "metadata"> & {
-    comments: CommentDataPlain[];
-    metadata: M;
-};
-declare type ThreadDeleteInfo = {
-    type: "deletedThread";
-    id: string;
-    roomId: string;
-    deletedAt: Date;
-};
-declare type StringOperators<T> = T | {
-    startsWith: string;
-};
 /**
- * This type can be used to build a metadata query string (compatible
- * with `@liveblocks/query-parser`) through a type-safe API.
+ * 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)
  *
- * In addition to exact values (`:` in query string), it adds:
- * - to strings:
- *  - `startsWith` (`^` in query string)
  */
-declare type QueryMetadata<M extends BaseMetadata> = {
-    [K in keyof M]: string extends M[K] ? StringOperators<M[K]> : M[K];
-};
-
-declare global {
-    /**
-     * Namespace for user-defined Liveblocks types.
-     */
-    export interface Liveblocks {
-        [key: string]: unknown;
-    }
+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 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.
+ * 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.
  *
- * @example
- * Object.defineProperty(
- *   {
- *     public,
- *     [kInternal]: {
- *       private
- *     },
- *   },
- *   kInternal,
- *   {
- *     enumerable: false,
- *   }
- * );
+ * 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 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;
+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 ClientMsgCode {
@@ -1442,32 +1488,6 @@ 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.
  */
@@ -1517,10 +1537,6 @@ declare type InternalOthersEvent<P extends JsonObject, U extends BaseUserMeta> =
 declare type OthersEvent<P extends JsonObject = DP, U extends BaseUserMeta = DU> = Resolve<InternalOthersEvent<P, U> & {
     others: readonly User<P, U>[];
 }>;
-declare enum TextEditorType {
-    Lexical = "lexical",
-    TipTap = "tiptap"
-}
 
 declare type OptionalKeys<T> = {
     [K in keyof T]-?: undefined extends T[K] ? K : never;
@@ -1788,11 +1804,15 @@ declare type SubscribeFn<P extends JsonObject, _TStorage extends LsonObject, U e
     (type: "comments", listener: Callback<CommentsEventServerMsg>): () => void;
 };
 declare type GetThreadsOptions<M extends BaseMetadata> = {
+    cursor?: string;
     query?: {
         resolved?: boolean;
         metadata?: Partial<QueryMetadata<M>>;
     };
 };
+declare type GetThreadsSinceOptions = {
+    since: Date;
+};
 declare type UploadAttachmentOptions = {
     signal?: AbortSignal;
 };
@@ -2019,6 +2039,7 @@ declare type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extend
         threads: ThreadData<M>[];
         inboxNotifications: InboxNotificationData[];
         requestedAt: Date;
+        nextCursor: string | null;
     }>;
     /**
      * Returns the updated and deleted threads and their associated inbox notifications since the requested date.
@@ -2028,9 +2049,7 @@ declare type Room<P extends JsonObject = DP, S extends LsonObject = DS, U extend
      * // ... //
      * await room.getThreadsSince({ since: result.requestedAt });
      */
-    getThreadsSince(options: {
-        since: Date;
-    }): Promise<{
+    getThreadsSince(options: GetThreadsSinceOptions): Promise<{
         threads: {
             updated: ThreadData<M>[];
             deleted: ThreadDeleteInfo[];
@@ -2238,7 +2257,7 @@ declare type PrivateRoomApi = {
     onProviderUpdate: Observable<void>;
     getSelf_forDevTools(): UserTreeNode | null;
     getOthers_forDevTools(): readonly UserTreeNode[];
-    reportTextEditor(editor: TextEditorType, rootKey: string): void;
+    reportTextEditor(editor: "lexical", rootKey: string): void;
     createTextMention(userId: string, mentionId: string): Promise<Response>;
     deleteTextMention(mentionId: string): Promise<Response>;
     listTextVersions(): Promise<Response>;
@@ -2288,26 +2307,6 @@ declare class CommentsApiError extends Error {
     constructor(message: string, status: number, details?: JsonObject | undefined);
 }
 
-/**
- * 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>;
 
 declare type ResolveMentionSuggestionsArgs = {
@@ -2375,12 +2374,13 @@ declare type PrivateClientApi<U extends BaseUserMeta, M extends BaseMetadata> =
     readonly usersStore: BatchStore<U["info"] | undefined, string>;
     readonly roomsInfoStore: BatchStore<DRI | undefined, string>;
     readonly getRoomIds: () => string[];
-    readonly getThreads: (options: GetThreadsOptions<M>) => Promise<{
+    readonly getUserThreads_experimental: (options: GetThreadsOptions<M>) => Promise<{
         threads: ThreadData<M>[];
         inboxNotifications: InboxNotificationData[];
+        nextCursor: string | null;
         requestedAt: Date;
     }>;
-    readonly getThreadsSince: (options: {
+    readonly getUserThreadsSince_experimental: (options: {
         since: Date;
     } & GetThreadsOptions<M>) => Promise<{
         inboxNotifications: {
@@ -2396,32 +2396,50 @@ declare type PrivateClientApi<U extends BaseUserMeta, M extends BaseMetadata> =
 };
 declare type NotificationsApi<M extends BaseMetadata> = {
     /**
-     * Gets the current user inbox notifications and their associated threads.
-     * It also returns the request date that can be used for subsequent polling.
+     * Gets a page (or the initial page) for user inbox notifications and their
+     * associated threads.
+     *
+     * This function should NOT be used for delta updates, only for pagination
+     * (including the first page fetch). For delta updates (done during the
+     * periodic polling), use the `getInboxNotificationsSince` function.
      *
      * @example
      * const {
      *   inboxNotifications,
      *   threads,
-     *   requestedAt
+     *   nextCursor,
      * } = await client.getInboxNotifications();
+     * 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(): Promise<{
+    getInboxNotifications(options?: {
+        cursor?: string;
+    }): Promise<{
         inboxNotifications: InboxNotificationData[];
         threads: ThreadData<M>[];
+        nextCursor: string | null;
         requestedAt: Date;
     }>;
     /**
-     * Gets the updated and deleted inbox notifications and their associated threads since the requested date.
+     * Fetches a "delta update" since the last time we updated.
+     *
+     * This function should NOT be used for pagination, for that, see the
+     * `getInboxNotifications` function.
      *
      * @example
-     * const result = await client.getInboxNotifications();
-     * // ... //
-     * await client.getInboxNotificationsSince({ since: result.requestedAt }});
-     */
-    getInboxNotificationsSince(options: {
-        since: Date;
-    }): Promise<{
+     * const {
+     *   inboxNotifications: {
+     *     updated,
+     *     deleted,
+     *   },
+     *   threads: {
+     *     updated,
+     *     deleted,
+     *    },
+     *   requestedAt,
+     * } = await client.getInboxNotificationsSince({ since: result.requestedAt }});
+     */
+    getInboxNotificationsSince(since: Date): Promise<{
         inboxNotifications: {
             updated: InboxNotificationData[];
             deleted: InboxNotificationDeleteInfo[];
@@ -2763,6 +2781,9 @@ declare function nn<T>(value: T, errmsg?: string): NonNullable<T>;
  * @param throwError An optional function to not auto-retry on certain errors
  */
 declare function autoRetry<T>(promiseFn: () => Promise<T>, maxTries: number, backoff: number[], throwError?: (err: any) => boolean): Promise<T>;
+declare class StopRetrying extends Error {
+    constructor(reason: string);
+}
 
 declare function chunk<T>(array: T[], size: number): T[][];
 
@@ -2851,13 +2872,14 @@ declare function objectToQuery(obj: {
 }): string;
 
 declare type Poller = {
-    start(interval: number): void;
-    restart(interval: number): void;
-    pause(): void;
-    resume(): void;
-    stop(): void;
+    /**
+     * Starts or stops the poller, based on the given condition. When true,
+     * starts the poller if it hasn't been started already. When false, stops the
+     * poller if it hasn't been stopped already.
+     */
+    enable(condition: boolean): void;
 };
-declare function makePoller(callback: () => Promise<void> | void): Poller;
+declare function makePoller(callback: () => Promise<void> | void, interval: number): Poller;
 
 declare const brand: unique symbol;
 declare type Brand<T, TBrand extends string> = T & {
@@ -2990,6 +3012,10 @@ declare function asPos(str: string): Pos;
 declare function shallow(a: unknown, b: unknown): boolean;
 
 declare type OmitFirstTupleElement<T extends any[]> = T extends [any, ...infer R] ? R : never;
+/**
+ * Like JSON.stringify(), but returns the same value no matter how the keys in
+ * objects are ordered.
+ */
 declare function stringify(object: Parameters<typeof JSON.stringify>[0], ...args: OmitFirstTupleElement<Parameters<typeof JSON.stringify>>): string;
 
 declare type QueryParams = Record<string, string | number | null | undefined> | URLSearchParams;
@@ -3150,4 +3176,4 @@ declare type EnsureJson<T> = T extends Json ? T : T extends Array<infer I> ? (En
     [K in keyof T as EnsureJson<T[K]> extends never ? never : K]: EnsureJson<T[K]>;
 };
 
-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, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IdTuple, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type 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 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 PrivateClientApi, type PrivateRoomApi, 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, type Status, type StorageStatus, type StorageUpdate, type Store, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, 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, 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, getMentionedIdsFromCommentBody, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, kInternal, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, mapValues, memoizeOnSuccess, nanoid, nn, objectToQuery, patchLiveObjectKey, raise, shallow, stringify, stringifyCommentBody, throwUsageError, 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, type IUserInfo, type IWebSocket, type IWebSocketCloseEvent, type IWebSocketEvent, type IWebSocketInstance, type IWebSocketMessageEvent, type IdTuple, type Immutable, type InboxNotificationCustomData, type InboxNotificationCustomDataPlain, type InboxNotificationData, type InboxNotificationDataPlain, type InboxNotificationDeleteInfo, type 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 PrivateClientApi, type PrivateRoomApi, 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, type Status, StopRetrying, type StorageStatus, type StorageUpdate, type Store, type StringifyCommentBodyElements, type StringifyCommentBodyOptions, 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, 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, getMentionedIdsFromCommentBody, isChildCrdt, isJsonArray, isJsonObject, isJsonScalar, isLiveNode, isPlainObject, isRootCrdt, kInternal, legacy_patchImmutableObject, lsonToJson, makeEventSource, makePoller, makePosition, mapValues, memoizeOnSuccess, nanoid, nn, objectToQuery, patchLiveObjectKey, raise, shallow, stringify, stringifyCommentBody, throwUsageError, toPlainLson, tryParseJson, url, urljoin, wait, withTimeout };