@liveblocks/react 2.9.3-experimental1 → 2.10.1-react19

package/dist/{suspense-fYGGJ3D9.d.ts → liveblocks-SAVcXwMX.d.ts}

@@ -1,30 +1,6 @@
-import { JsonObject, LsonObject, BaseUserMeta, LiveObject, User, RoomNotificationSettings, Json, Room, Status, BroadcastOptions, OthersEvent, LostConnectionEvent, History, BaseMetadata as BaseMetadata$1, Client as Client$1, ClientOptions, StorageStatus as StorageStatus$1, CommentData as CommentData$1 } from '@liveblocks/client';
-import * as React$1 from 'react';
-import React__default, { ReactNode, PropsWithChildren } from 'react';
-import { BaseMetadata, CommentBody, Patchable, StorageStatus, QueryMetadata, AsyncResult, DRI, AsyncSuccess, CommentAttachment, InboxNotificationData, Resolve, ToImmutable, AsyncLoading, AsyncError, ThreadData, HistoryVersion, Client, LiveblocksError, RoomEventMessage, CommentData, PartialUnless, ThreadDataWithDeleteInfo, RoomNotificationSettings as RoomNotificationSettings$1, OpaqueClient, CommentUserReaction, ThreadDeleteInfo, InboxNotificationDeleteInfo, DistributiveOmit, DU, DM, OpaqueRoom, DP, DS, DE } from '@liveblocks/core';
-
-declare type Props = {
-    fallback: ReactNode;
-    children: (() => ReactNode | undefined) | ReactNode | undefined;
-};
-/**
- * Almost like a normal <Suspense> component, except that for server-side
- * renders, the fallback will be used.
- *
- * The child props will have to be provided in a function, i.e. change:
- *
- *   <Suspense fallback={<Loading />}>
- *     <MyRealComponent a={1} />
- *   </Suspense>
- *
- * To:
- *
- *   <ClientSideSuspense fallback={<Loading />}>
- *     <MyRealComponent a={1} />
- *   </ClientSideSuspense>
- *
- */
-declare function ClientSideSuspense(props: Props): React$1.JSX.Element;
+import { JsonObject, LsonObject, BaseUserMeta, LiveObject, User, Json, RoomNotificationSettings, Room, Status, BroadcastOptions, OthersEvent, LostConnectionEvent, History, BaseMetadata as BaseMetadata$1, Client as Client$1, ClientOptions } from '@liveblocks/client';
+import { BaseMetadata, CommentBody, Patchable, StorageStatus, QueryMetadata, AsyncResult, DRI, AsyncSuccess, CommentAttachment, InboxNotificationData, Resolve, ToImmutable, AsyncLoading, AsyncError, ThreadData, HistoryVersion, Client, LiveblocksError, RoomEventMessage, CommentData, PartialUnless, ThreadDataWithDeleteInfo, OpaqueClient, CommentUserReaction, ThreadDeleteInfo, InboxNotificationDeleteInfo, RoomNotificationSettings as RoomNotificationSettings$1, DistributiveOmit, DU, DM } from '@liveblocks/core';
+import React__default, { PropsWithChildren } from 'react';
 
 /**
  * @private Internal API, do not rely on it.
@@ -46,6 +22,9 @@ declare class CreateThreadError<M extends BaseMetadata> extends Error {
         metadata: M;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class EditThreadMetadataError<M extends BaseMetadata> extends Error {
     cause: Error;
     context: {
@@ -59,6 +38,9 @@ declare class EditThreadMetadataError<M extends BaseMetadata> extends Error {
         metadata: Patchable<M>;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class CreateCommentError extends Error {
     cause: Error;
     context: {
@@ -74,6 +56,9 @@ declare class CreateCommentError extends Error {
         body: CommentBody;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class EditCommentError extends Error {
     cause: Error;
     context: {
@@ -89,6 +74,9 @@ declare class EditCommentError extends Error {
         body: CommentBody;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class DeleteCommentError extends Error {
     cause: Error;
     context: {
@@ -102,6 +90,9 @@ declare class DeleteCommentError extends Error {
         commentId: string;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class MarkInboxNotificationAsReadError extends Error {
     cause: Error;
     context: {
@@ -111,6 +102,9 @@ declare class MarkInboxNotificationAsReadError extends Error {
         inboxNotificationId: string;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class UpdateNotificationSettingsError extends Error {
     cause: Error;
     context: {
@@ -120,6 +114,9 @@ declare class UpdateNotificationSettingsError extends Error {
         roomId: string;
     });
 }
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare type CommentsError<M extends BaseMetadata> = CreateThreadError<M> | EditThreadMetadataError<M> | CreateCommentError | EditCommentError | DeleteCommentError | MarkInboxNotificationAsReadError | UpdateNotificationSettingsError;
 
 declare type UseStorageStatusOptions = {
@@ -1064,6 +1061,61 @@ declare type LiveblocksContextBundle<U extends BaseUserMeta, M extends BaseMetad
     }>;
 }>;
 
+declare type ReadonlyThreadDB<M extends BaseMetadata> = Omit<ThreadDB<M>, "upsert" | "delete">;
+/**
+ * This class implements a lightweight, in-memory, "database" for all Thread
+ * instances.
+ *
+ * It exposes the following methods:
+ *
+ * - upsert: To add/update a thread
+ * - upsertIfNewer: To add/update a thread. Only update an existing thread if
+ *                  its newer
+ * - delete: To mark existing threads as deleted
+ * - get: To get any non-deleted thread
+ * - getEvenIfDeleted: To get a thread which is possibly deleted
+ * - findMany: To filter an ordered list of non-deleted threads
+ * - clone: To clone the DB to mutate it further. This is used to mix in
+ *          optimistic updates without losing the original thread contents.
+ *
+ */
+declare class ThreadDB<M extends BaseMetadata> {
+    private _byId;
+    private _asc;
+    private _desc;
+    private _version;
+    constructor();
+    clone(): ThreadDB<M>;
+    /** Gets the transaction count for this DB. Increments any time the DB is modified. */
+    get version(): number;
+    /** Returns an existing thread by ID. Will never return a deleted thread. */
+    get(threadId: string): ThreadData<M> | undefined;
+    /** Returns the (possibly deleted) thread by ID. */
+    getEvenIfDeleted(threadId: string): ThreadDataWithDeleteInfo<M> | undefined;
+    /** Adds or updates a thread in the DB. If the newly given thread is a deleted one, it will get deleted. */
+    upsert(thread: ThreadDataWithDeleteInfo<M>): void;
+    /** Like .upsert(), except it won't update if a thread by this ID already exists. */
+    upsertIfNewer(thread: ThreadDataWithDeleteInfo<M>): void;
+    /**
+     * Marks a thread as deleted. It will no longer pop up in .findMany()
+     * queries, but it can still be accessed via `.getEvenIfDeleted()`.
+     */
+    delete(threadId: string, deletedAt: Date): void;
+    /**
+     * Returns all threads matching a given roomId and query. If roomId is not
+     * specified, it will return all threads matching the query, across all
+     * rooms.
+     *
+     * Returns the results in the requested order. Please note:
+     *   'asc'  means by createdAt ASC
+     *   'desc' means by updatedAt DESC
+     *
+     * Will never return deleted threads in the result.
+     */
+    findMany(roomId: string | undefined, query: ThreadsQuery<M>, direction: "asc" | "desc"): ThreadData<M>[];
+    private touch;
+}
+
 declare type OptimisticUpdate<M extends BaseMetadata> = CreateThreadOptimisticUpdate<M> | DeleteThreadOptimisticUpdate | EditThreadMetadataOptimisticUpdate<M> | MarkThreadAsResolvedOptimisticUpdate | MarkThreadAsUnresolvedOptimisticUpdate | CreateCommentOptimisticUpdate | EditCommentOptimisticUpdate | DeleteCommentOptimisticUpdate | AddReactionOptimisticUpdate | RemoveReactionOptimisticUpdate | MarkInboxNotificationAsReadOptimisticUpdate | MarkAllInboxNotificationsAsReadOptimisticUpdate | DeleteInboxNotificationOptimisticUpdate | DeleteAllInboxNotificationsOptimisticUpdate | UpdateNotificationSettingsOptimisticUpdate;
 declare type CreateThreadOptimisticUpdate<M extends BaseMetadata> = {
     type: "create-thread";
@@ -1159,15 +1211,6 @@ declare type UpdateNotificationSettingsOptimisticUpdate = {
     roomId: string;
     settings: Partial<RoomNotificationSettings$1>;
 };
-declare type QueryAsyncResult = AsyncResult<undefined>;
-/**
- * @private Do not rely on this internal API.
- */
-declare function selectThreads<M extends BaseMetadata>(state: UmbrellaStoreState<M>, options: {
-    roomId: string | null;
-    query?: ThreadsQuery<M>;
-    orderBy: "age" | "last-update";
-}): ThreadData<M>[];
 /**
  * Like Promise<T>, except it will have a synchronously readable `status`
  * field, indicating the status of the promise.
@@ -1193,23 +1236,11 @@ declare type UmbrellaStoreState<M extends BaseMetadata> = {
      * e.g. 'room-abc-{"color":"red"}'  - ok
      * e.g. 'room-abc-{}'               - loading
      */
-    queries3: Record<string, QueryAsyncResult>;
-    queries4: Record<string, QueryAsyncResult>;
-    /**
-     * All threads in a sorted array, optimistic updates applied, without deleted
-     * threads.
-     */
-    threads: ThreadData<M>[];
-    /**
-     * All threads in a map, keyed by thread ID, with all optimistic updates
-     * applied. Deleted threads are still in this mapping, and will have
-     * a deletedAt field if so.
-     */
-    threadsById: Record<string, ThreadDataWithDeleteInfo<M>>;
+    threadsDB: ReadonlyThreadDB<M>;
     /**
      * All inbox notifications in a sorted array, optimistic updates applied.
      */
-    notifications: InboxNotificationData[];
+    cleanedNotifications: InboxNotificationData[];
     /**
      * Inbox notifications by ID.
      * e.g. `in_${string}`
@@ -1227,10 +1258,12 @@ declare type UmbrellaStoreState<M extends BaseMetadata> = {
      * Versions by roomId
      * e.g. { 'room-abc': {versions: "all versions"}}
      */
-    versionsByRoomId: Record<string, HistoryVersion[]>;
+    versionsByRoomId: Record<string, Record<string, HistoryVersion>>;
 };
 declare class UmbrellaStore<M extends BaseMetadata> {
-    private _client?;
+    private _client;
+    private _rawThreadsDB;
+    private _prevVersion;
     private _store;
     private _prevState;
     private _stateCached;
@@ -1240,7 +1273,10 @@ declare class UmbrellaStore<M extends BaseMetadata> {
     private _roomThreads;
     private _userThreadsLastRequestedAt;
     private _userThreads;
-    constructor(client?: OpaqueClient);
+    private _roomVersions;
+    private _roomVersionsLastRequestedAtByRoom;
+    private _roomNotificationSettings;
+    constructor(client: OpaqueClient);
     private get;
     batch(callback: () => void): void;
     getFullState(): UmbrellaStoreState<M>;
@@ -1249,31 +1285,20 @@ declare class UmbrellaStore<M extends BaseMetadata> {
      * then it will return the threads that match that provided query and room id.
      *
      */
-    getRoomThreadsAsync(roomId: string, query: ThreadsQuery<M> | undefined): ThreadsAsyncResult<M>;
-    getUserThreadsAsync(query: ThreadsQuery<M> | undefined): ThreadsAsyncResult<M>;
-    getInboxNotificationsAsync(): InboxNotificationsAsyncResult;
-    getNotificationSettingsAsync(roomId: string): RoomNotificationSettingsAsyncResult;
-    getVersionsAsync(roomId: string): AsyncResult<HistoryVersion[], "versions">;
+    getRoomThreadsLoadingState(roomId: string, query: ThreadsQuery<M> | undefined): ThreadsAsyncResult<M>;
+    getUserThreadsLoadingState(query: ThreadsQuery<M> | undefined): ThreadsAsyncResult<M>;
+    getInboxNotificationsLoadingState(): InboxNotificationsAsyncResult;
+    getNotificationSettingsLoadingState(roomId: string): RoomNotificationSettingsAsyncResult;
+    getRoomVersionsLoadingState(roomId: string): AsyncResult<HistoryVersion[], "versions">;
     /**
      * @private Only used by the E2E test suite.
      */
     _hasOptimisticUpdates(): boolean;
-    private subscribe;
-    /**
-     * @private Only used by the E2E test suite.
-     */
-    _subscribeOptimisticUpdates(callback: () => void): () => void;
-    subscribeThreads(callback: () => void): () => void;
-    subscribeUserThreads(callback: () => void): () => void;
-    subscribeThreadsOrInboxNotifications(callback: () => void): () => void;
-    subscribeNotificationSettings(callback: () => void): () => void;
-    subscribeVersions(callback: () => void): () => void;
-    private updateThreadsCache;
+    subscribe(callback: () => void): () => void;
+    private mutateThreadsDB;
     private updateInboxNotificationsCache;
     private setNotificationSettings;
-    private setVersions;
-    private setQuery3State;
-    private setQuery4State;
+    private updateRoomVersions;
     private updateOptimisticUpdatesCache;
     /**
      * Updates an existing inbox notification with a new value, replacing the
@@ -1342,23 +1367,19 @@ declare class UmbrellaStore<M extends BaseMetadata> {
      * Updates existing notification setting for a room with a new value,
      * replacing the corresponding optimistic update.
      */
-    updateRoomInboxNotificationSettings2(roomId: string, optimisticUpdateId: string, settings: Readonly<RoomNotificationSettings$1>): void;
-    updateRoomInboxNotificationSettings(roomId: string, settings: RoomNotificationSettings$1, queryKey: string): void;
-    updateRoomVersions(roomId: string, versions: HistoryVersion[], queryKey?: string): void;
+    updateRoomNotificationSettings_confirmOptimisticUpdate(roomId: string, optimisticUpdateId: string, settings: Readonly<RoomNotificationSettings$1>): void;
     addOptimisticUpdate(optimisticUpdate: DistributiveOmit<OptimisticUpdate<M>, "id">): string;
     removeOptimisticUpdate(optimisticUpdateId: string): void;
-    setQuery3Loading(queryKey: string): void;
-    private setQuery3OK;
-    setQuery3Error(queryKey: string, error: Error): void;
-    setQuery4Loading(queryKey: string): void;
-    private setQuery4OK;
-    setQuery4Error(queryKey: string, error: Error): void;
-    fetchNotificationsDeltaUpdate(): Promise<void>;
+    fetchNotificationsDeltaUpdate(signal: AbortSignal): Promise<void>;
     waitUntilNotificationsLoaded(): UsablePromise<void>;
     waitUntilRoomThreadsLoaded(roomId: string, query: ThreadsQuery<M> | undefined): UsablePromise<void>;
-    fetchRoomThreadsDeltaUpdate(roomId: string): Promise<void>;
+    fetchRoomThreadsDeltaUpdate(roomId: string, signal: AbortSignal): Promise<void>;
     waitUntilUserThreadsLoaded(query: ThreadsQuery<M> | undefined): UsablePromise<void>;
-    fetchUserThreadsDeltaUpdate(): Promise<void>;
+    fetchUserThreadsDeltaUpdate(signal: AbortSignal): Promise<void>;
+    waitUntilRoomVersionsLoaded(roomId: string): UsablePromise<void>;
+    fetchRoomVersionsDeltaUpdate(roomId: string, signal: AbortSignal): Promise<void>;
+    waitUntilRoomNotificationSettingsLoaded(roomId: string): UsablePromise<void>;
+    refreshRoomNotificationSettings(roomId: string, signal: AbortSignal): Promise<void>;
 }
 
 /**
@@ -1479,7 +1500,7 @@ declare function useRoomInfo(roomId: string): RoomInfoAsyncResult;
  * const { info } = useRoomInfo("room-id");
  */
 declare function useRoomInfoSuspense(roomId: string): RoomInfoAsyncSuccess;
-declare type TypedBundle$1 = LiveblocksContextBundle<DU, DM>;
+declare type TypedBundle = LiveblocksContextBundle<DU, DM>;
 /**
  * Returns the thread associated with a `"thread"` inbox notification.
  *
@@ -1495,21 +1516,21 @@ declare type TypedBundle$1 = LiveblocksContextBundle<DU, DM>;
  * @example
  * const thread = useInboxNotificationThread("in_xxx");
  */
-declare const _useInboxNotificationThread: TypedBundle$1["useInboxNotificationThread"];
+declare const _useInboxNotificationThread: TypedBundle["useInboxNotificationThread"];
 /**
  * Returns user info from a given user ID.
  *
  * @example
  * const { user, error, isLoading } = useUser("user-id");
  */
-declare const _useUser: TypedBundle$1["useUser"];
+declare const _useUser: TypedBundle["useUser"];
 /**
  * Returns user info from a given user ID.
  *
  * @example
  * const { user } = useUser("user-id");
  */
-declare const _useUserSuspense: TypedBundle$1["suspense"]["useUser"];
+declare const _useUserSuspense: TypedBundle["suspense"]["useUser"];
 /**
  * @experimental
  *
@@ -1525,7 +1546,7 @@ declare const _useUserSuspense: TypedBundle$1["suspense"]["useUser"];
  * specify the sort order to be by most recently updated first somehow.
  * The final API for that is still TBD.
  */
-declare const _useUserThreads_experimental: TypedBundle$1["useUserThreads_experimental"];
+declare const _useUserThreads_experimental: TypedBundle["useUserThreads_experimental"];
 /**
  * @experimental
  *
@@ -1541,697 +1562,6 @@ declare const _useUserThreads_experimental: TypedBundle$1["useUserThreads_experi
  * specify the sort order to be by most recently updated first somehow.
  * The final API for that is still TBD.
  */
-declare const _useUserThreadsSuspense_experimental: TypedBundle$1["suspense"]["useUserThreads_experimental"];
-
-/**
- * Raw access to the React context where the RoomProvider stores the current
- * room. Exposed for advanced use cases only.
- *
- * @private This is a private/advanced API. Do not rely on it.
- */
-declare const RoomContext: React$1.Context<OpaqueRoom | null>;
-
-/**
- * Returns the current connection status for the Room, and triggers
- * a re-render whenever it changes. Can be used to render a status badge.
- */
-declare function useStatus(): Status;
-/**
- * Returns the current storage status for the Room, and triggers
- * a re-render whenever it changes. Can be used to render a "Saving..."
- * indicator.
- */
-declare function useStorageStatus(options?: UseStorageStatusOptions): StorageStatus$1;
-/**
- * @deprecated It's recommended to use `useMutation` for writing to Storage,
- * which will automatically batch all mutations.
- *
- * Returns a function that batches modifications made during the given function.
- * All the modifications are sent to other clients in a single message.
- * All the modifications are merged in a single history item (undo/redo).
- * All the subscribers are called only after the batch is over.
- */
-declare function useBatch<T>(): (callback: () => T) => T;
-/**
- * Get informed when reconnecting to the Liveblocks servers is taking
- * longer than usual. This typically is a sign of a client that has lost
- * internet connectivity.
- *
- * This isn't problematic (because the Liveblocks client is still trying to
- * reconnect), but it's typically a good idea to inform users about it if
- * the connection takes too long to recover.
- *
- * @example
- * useLostConnectionListener(event => {
- *   if (event === 'lost') {
- *     toast.warn('Reconnecting to the Liveblocks servers is taking longer than usual...')
- *   } else if (event === 'failed') {
- *     toast.warn('Reconnecting to the Liveblocks servers failed.')
- *   } else if (event === 'restored') {
- *     toast.clear();
- *   }
- * })
- */
-declare function useLostConnectionListener(callback: (event: LostConnectionEvent) => void): void;
-/**
- * useErrorListener is a React hook that allows you to respond to potential room
- * connection errors.
- *
- * @example
- * useErrorListener(er => {
- *   console.error(er);
- * })
- */
-declare function useErrorListener(callback: (err: LiveblocksError) => void): void;
-/**
- * Returns the room.history
- */
-declare function useHistory(): History;
-/**
- * Returns a function that undoes the last operation executed by the current
- * client. It does not impact operations made by other clients.
- */
-declare function useUndo(): () => void;
-/**
- * Returns a function that redoes the last operation executed by the current
- * client. It does not impact operations made by other clients.
- */
-declare function useRedo(): () => void;
-/**
- * Returns whether there are any operations to undo.
- */
-declare function useCanUndo(): boolean;
-/**
- * Returns whether there are any operations to redo.
- */
-declare function useCanRedo(): boolean;
-/**
- * Returns an array of connection IDs. This matches the values you'll get by
- * using the `useOthers()` hook.
- *
- * Roughly equivalent to:
- *   useOthers((others) => others.map(other => other.connectionId), shallow)
- *
- * This is useful in particular to implement efficiently rendering components
- * for each user in the room, e.g. cursors.
- *
- * @example
- * const ids = useOthersConnectionIds();
- * // [2, 4, 7]
- */
-declare function useOthersConnectionIds(): readonly number[];
-/**
- * @private Internal API, do not rely on it.
- */
-declare function useCommentsErrorListener<M extends BaseMetadata$1>(callback: (error: CommentsError<M>) => void): void;
-/**
- * Returns a function that adds a comment to a thread.
- *
- * @example
- * const createComment = useCreateComment();
- * createComment({ threadId: "th_xxx", body: {} });
- */
-declare function useCreateComment(): (options: CreateCommentOptions) => CommentData$1;
-/**
- * Returns a function that edits a comment's body.
- *
- * @example
- * const editComment = useEditComment()
- * editComment({ threadId: "th_xxx", commentId: "cm_xxx", body: {} })
- */
-declare function useEditComment(): (options: EditCommentOptions) => void;
-/**
- * Returns a function that deletes a comment.
- * If it is the last non-deleted comment, the thread also gets deleted.
- *
- * @example
- * const deleteComment = useDeleteComment();
- * deleteComment({ threadId: "th_xxx", commentId: "cm_xxx" })
- */
-declare function useDeleteComment(): ({ threadId, commentId }: DeleteCommentOptions) => void;
-/**
- * Returns a function that removes a reaction on a comment.
- *
- * @example
- * const removeReaction = useRemoveReaction();
- * removeReaction({ threadId: "th_xxx", commentId: "cm_xxx", emoji: "👍" })
- */
-declare function useRemoveReaction(): ({ threadId, commentId, emoji }: CommentReactionOptions) => void;
-/**
- * Returns a function that marks a thread as read.
- *
- * @example
- * const markThreadAsRead = useMarkThreadAsRead();
- * markThreadAsRead("th_xxx");
- */
-declare function useMarkThreadAsRead(): (threadId: string) => void;
-/**
- * Returns a function that marks a thread as resolved.
- *
- * @example
- * const markThreadAsResolved = useMarkThreadAsResolved();
- * markThreadAsResolved("th_xxx");
- */
-declare function useMarkThreadAsResolved(): (threadId: string) => void;
-/**
- * Returns a function that marks a thread as unresolved.
- *
- * @example
- * const markThreadAsUnresolved = useMarkThreadAsUnresolved();
- * markThreadAsUnresolved("th_xxx");
- */
-declare function useMarkThreadAsUnresolved(): (threadId: string) => void;
-/**
- * Returns the subscription status of a thread.
- *
- * @example
- * const { status, unreadSince } = useThreadSubscription("th_xxx");
- */
-declare function useThreadSubscription(threadId: string): ThreadSubscription;
-/**
- * Returns the user's notification settings for the current room
- * and a function to update them.
- *
- * @example
- * const [{ settings }, updateSettings] = useRoomNotificationSettings();
- */
-declare function useRoomNotificationSettings(): [
-    RoomNotificationSettingsAsyncResult,
-    (settings: Partial<RoomNotificationSettings>) => void
-];
-/**
- * Returns the version data bianry for a given version
- *
- * @example
- * const {data} = useHistoryVersionData(versionId);
- */
-declare function useHistoryVersionData(versionId: string): HistoryVersionDataAsyncResult;
-/**
- * Returns a function that updates the user's notification settings
- * for the current room.
- *
- * @example
- * const updateRoomNotificationSettings = useUpdateRoomNotificationSettings();
- * updateRoomNotificationSettings({ threads: "all" });
- */
-declare function useUpdateRoomNotificationSettings(): (settings: Partial<RoomNotificationSettings>) => void;
-/**
- * Returns an array of connection IDs. This matches the values you'll get by
- * using the `useOthers()` hook.
- *
- * Roughly equivalent to:
- *   useOthers((others) => others.map(other => other.connectionId), shallow)
- *
- * This is useful in particular to implement efficiently rendering components
- * for each user in the room, e.g. cursors.
- *
- * @example
- * const ids = useOthersConnectionIds();
- * // [2, 4, 7]
- */
-declare function useOthersConnectionIdsSuspense(): readonly number[];
-/**
- * Returns the current storage status for the Room, and triggers
- * a re-render whenever it changes. Can be used to render a "Saving..."
- * indicator.
- */
-declare function useStorageStatusSuspense(options?: UseStorageStatusOptions): StorageStatusSuccess;
-/**
- * Returns a presigned URL for an attachment by its ID.
- *
- * @example
- * const { url, error, isLoading } = useAttachmentUrl("at_xxx");
- */
-declare function useAttachmentUrl(attachmentId: string): AttachmentUrlAsyncResult;
-/**
- * Returns a presigned URL for an attachment by its ID.
- *
- * @example
- * const { url } = useAttachmentUrl("at_xxx");
- */
-declare function useAttachmentUrlSuspense(attachmentId: string): {
-    readonly isLoading: false;
-    readonly url: string;
-    readonly error: undefined;
-};
-/**
- * Creates a RoomProvider and a set of typed hooks to use in your app. Note
- * that any RoomProvider created in this way does not need to be nested in
- * LiveblocksProvider, as it already has access to the client.
- */
-declare function createRoomContext<P extends JsonObject = DP, S extends LsonObject = DS, U extends BaseUserMeta = DU, E extends Json = DE, M extends BaseMetadata$1 = DM>(client: OpaqueClient): RoomContextBundle<P, S, U, E, M>;
-declare type TypedBundle = RoomContextBundle<DP, DS, DU, DE, DM>;
-/**
- * Makes a Room available in the component hierarchy below.
- * Joins the room when the component is mounted, and automatically leaves
- * the room when the component is unmounted.
- */
-declare const _RoomProvider: TypedBundle["RoomProvider"];
-/**
- * Returns a callback that lets you broadcast custom events to other users in the room
- *
- * @example
- * const broadcast = useBroadcastEvent();
- *
- * broadcast({ type: "CUSTOM_EVENT", data: { x: 0, y: 0 } });
- */
-declare const _useBroadcastEvent: TypedBundle["useBroadcastEvent"];
-/**
- * Get informed when users enter or leave the room, as an event.
- *
- * @example
- * useOthersListener({ type, user, others }) => {
- *   if (type === 'enter') {
- *     // `user` has joined the room
- *   } else if (type === 'leave') {
- *     // `user` has left the room
- *   }
- * })
- */
-declare const _useOthersListener: TypedBundle["useOthersListener"];
-/**
- * Returns the Room of the nearest RoomProvider above in the React component
- * tree.
- */
-declare const _useRoom: TypedBundle["useRoom"];
-/**
- * Returns whether the hook is called within a RoomProvider context.
- *
- * @example
- * const isInsideRoom = useIsInsideRoom();
- */
-declare const _useIsInsideRoom: TypedBundle["useIsInsideRoom"];
-/**
- * Returns a function that adds a reaction from a comment.
- *
- * @example
- * const addReaction = useAddReaction();
- * addReaction({ threadId: "th_xxx", commentId: "cm_xxx", emoji: "👍" })
- */
-declare const _useAddReaction: TypedBundle["useAddReaction"];
-/**
- * Create a callback function that lets you mutate Liveblocks state.
- *
- * The first argument that gets passed into your callback will be
- * a "mutation context", which exposes the following:
- *
- *   - `storage` - The mutable Storage root.
- *                 You can mutate any Live structures with this, for example:
- *                 `storage.get('layers').get('layer1').set('fill', 'red')`
- *
- *   - `setMyPresence` - Call this with a new (partial) Presence value.
- *
- *   - `self` - A read-only version of the latest self, if you need it to
- *              compute the next state.
- *
- *   - `others` - A read-only version of the latest others list, if you
- *                need it to compute the next state.
- *
- * useMutation is like React's useCallback, except that the first argument
- * that gets passed into your callback will be a "mutation context".
- *
- * If you want get access to the immutable root somewhere in your mutation,
- * you can use `storage.ToImmutable()`.
- *
- * @example
- * const fillLayers = useMutation(
- *   ({ storage }, color: Color) => {
- *     ...
- *   },
- *   [],
- * );
- *
- * fillLayers('red');
- *
- * const deleteLayers = useMutation(
- *   ({ storage }) => {
- *     ...
- *   },
- *   [],
- * );
- *
- * deleteLayers();
- */
-declare const _useMutation: TypedBundle["useMutation"];
-/**
- * Returns a function that creates a thread with an initial comment, and optionally some metadata.
- *
- * @example
- * const createThread = useCreateThread();
- * createThread({ body: {}, metadata: {} });
- */
-declare const _useCreateThread: TypedBundle["useCreateThread"];
-/**
- * Returns a function that deletes a thread and its associated comments.
- * Only the thread creator can delete a thread, it will throw otherwise.
- *
- * @example
- * const deleteThread = useDeleteThread();
- * deleteThread("th_xxx");
- */
-declare const _useDeleteThread: TypedBundle["useDeleteThread"];
-/**
- * Returns a function that edits a thread's metadata.
- * To delete an existing metadata property, set its value to `null`.
- *
- * @example
- * const editThreadMetadata = useEditThreadMetadata();
- * editThreadMetadata({ threadId: "th_xxx", metadata: {} })
- */
-declare const _useEditThreadMetadata: TypedBundle["useEditThreadMetadata"];
-/**
- * useEventListener is a React hook that allows you to respond to events broadcast
- * by other users in the room.
- *
- * The `user` argument will indicate which `User` instance sent the message.
- * This will be equal to one of the others in the room, but it can be `null`
- * in case this event was broadcasted from the server.
- *
- * @example
- * useEventListener(({ event, user, connectionId }) => {
- * //                         ^^^^ Will be Client A
- *   if (event.type === "CUSTOM_EVENT") {
- *     // Do something
- *   }
- * });
- */
-declare const _useEventListener: TypedBundle["useEventListener"];
-/**
- * Returns the presence of the current user of the current room, and a function to update it.
- * It is different from the setState function returned by the useState hook from React.
- * You don't need to pass the full presence object to update it.
- *
- * @example
- * const [myPresence, updateMyPresence] = useMyPresence();
- * updateMyPresence({ x: 0 });
- * updateMyPresence({ y: 0 });
- *
- * // At the next render, "myPresence" will be equal to "{ x: 0, y: 0 }"
- */
-declare const _useMyPresence: TypedBundle["useMyPresence"];
-/**
- * Related to useOthers(), but optimized for selecting only "subsets" of
- * others. This is useful for performance reasons in particular, because
- * selecting only a subset of users also means limiting the number of
- * re-renders that will be triggered.
- *
- * @example
- * const avatars = useOthersMapped(user => user.info.avatar);
- * //    ^^^^^^^
- * //    { connectionId: number; data: string }[]
- *
- * The selector function you pass to useOthersMapped() is called an "item
- * selector", and operates on a single user at a time. If you provide an
- * (optional) "item comparison" function, it will be used to compare each
- * item pairwise.
- *
- * For example, to select multiple properties:
- *
- * @example
- * const avatarsAndCursors = useOthersMapped(
- *   user => [u.info.avatar, u.presence.cursor],
- *   shallow,  // 👈
- * );
- */
-declare const _useOthersMapped: TypedBundle["useOthersMapped"];
-/**
- * Related to useOthers(), but optimized for selecting only "subsets" of
- * others. This is useful for performance reasons in particular, because
- * selecting only a subset of users also means limiting the number of
- * re-renders that will be triggered.
- *
- * @example
- * const avatars = useOthersMapped(user => user.info.avatar);
- * //    ^^^^^^^
- * //    { connectionId: number; data: string }[]
- *
- * The selector function you pass to useOthersMapped() is called an "item
- * selector", and operates on a single user at a time. If you provide an
- * (optional) "item comparison" function, it will be used to compare each
- * item pairwise.
- *
- * For example, to select multiple properties:
- *
- * @example
- * const avatarsAndCursors = useOthersMapped(
- *   user => [u.info.avatar, u.presence.cursor],
- *   shallow,  // 👈
- * );
- */
-declare const _useOthersMappedSuspense: TypedBundle["suspense"]["useOthersMapped"];
-/**
- * Returns the threads within the current room.
- *
- * @example
- * const { threads, error, isLoading } = useThreads();
- */
-declare const _useThreads: TypedBundle["useThreads"];
-/**
- * Returns the threads within the current room.
- *
- * @example
- * const { threads } = useThreads();
- */
-declare const _useThreadsSuspense: TypedBundle["suspense"]["useThreads"];
-/**
- * (Private beta) Returns a history of versions of the current room.
- *
- * @example
- * const { versions, error, isLoading } = useHistoryVersions();
- */
-declare const _useHistoryVersions: TypedBundle["useHistoryVersions"];
-/**
- * (Private beta) Returns a history of versions of the current room.
- *
- * @example
- * const { versions } = useHistoryVersions();
- */
-declare const _useHistoryVersionsSuspense: TypedBundle["suspense"]["useHistoryVersions"];
-/**
- * Given a connection ID (as obtained by using `useOthersConnectionIds`), you
- * can call this selector deep down in your component stack to only have the
- * component re-render if properties for this particular user change.
- *
- * @example
- * // Returns only the selected values re-renders whenever that selection changes)
- * const { x, y } = useOther(2, user => user.presence.cursor);
- */
-declare const _useOther: TypedBundle["useOther"];
-/**
- * Returns an array with information about all the users currently connected in
- * the room (except yourself).
- *
- * @example
- * const others = useOthers();
- *
- * // Example to map all cursors in JSX
- * return (
- *   <>
- *     {others.map((user) => {
- *        if (user.presence.cursor == null) {
- *          return null;
- *        }
- *        return <Cursor key={user.connectionId} cursor={user.presence.cursor} />
- *      })}
- *   </>
- * )
- */
-declare function _useOthers(): readonly User<DP, DU>[];
-/**
- * Extract arbitrary data based on all the users currently connected in the
- * room (except yourself).
- *
- * The selector function will get re-evaluated any time a user enters or
- * leaves the room, as well as whenever their presence data changes.
- *
- * The component that uses this hook will automatically re-render if your
- * selector function returns a different value from its previous run.
- *
- * By default `useOthers()` uses strict `===` to check for equality. Take
- * extra care when returning a computed object or list, for example when you
- * return the result of a .map() or .filter() call from the selector. In
- * those cases, you'll probably want to use a `shallow` comparison check.
- *
- * @example
- * const avatars = useOthers(users => users.map(u => u.info.avatar), shallow);
- * const cursors = useOthers(users => users.map(u => u.presence.cursor), shallow);
- * const someoneIsTyping = useOthers(users => users.some(u => u.presence.isTyping));
- *
- */
-declare function _useOthers<T>(selector: (others: readonly User<DP, DU>[]) => T, isEqual?: (prev: T, curr: T) => boolean): T;
-/**
- * Given a connection ID (as obtained by using `useOthersConnectionIds`), you
- * can call this selector deep down in your component stack to only have the
- * component re-render if properties for this particular user change.
- *
- * @example
- * // Returns only the selected values re-renders whenever that selection changes)
- * const { x, y } = useOther(2, user => user.presence.cursor);
- */
-declare const _useOtherSuspense: TypedBundle["suspense"]["useOther"];
-/**
- * Returns an array with information about all the users currently connected in
- * the room (except yourself).
- *
- * @example
- * const others = useOthers();
- *
- * // Example to map all cursors in JSX
- * return (
- *   <>
- *     {others.map((user) => {
- *        if (user.presence.cursor == null) {
- *          return null;
- *        }
- *        return <Cursor key={user.connectionId} cursor={user.presence.cursor} />
- *      })}
- *   </>
- * )
- */
-declare function _useOthersSuspense(): readonly User<DP, DU>[];
-/**
- * Extract arbitrary data based on all the users currently connected in the
- * room (except yourself).
- *
- * The selector function will get re-evaluated any time a user enters or
- * leaves the room, as well as whenever their presence data changes.
- *
- * The component that uses this hook will automatically re-render if your
- * selector function returns a different value from its previous run.
- *
- * By default `useOthers()` uses strict `===` to check for equality. Take
- * extra care when returning a computed object or list, for example when you
- * return the result of a .map() or .filter() call from the selector. In
- * those cases, you'll probably want to use a `shallow` comparison check.
- *
- * @example
- * const avatars = useOthers(users => users.map(u => u.info.avatar), shallow);
- * const cursors = useOthers(users => users.map(u => u.presence.cursor), shallow);
- * const someoneIsTyping = useOthers(users => users.some(u => u.presence.isTyping));
- *
- */
-declare function _useOthersSuspense<T>(selector: (others: readonly User<DP, DU>[]) => T, isEqual?: (prev: T, curr: T) => boolean): T;
-/**
- * Extract arbitrary data from the Liveblocks Storage state, using an
- * arbitrary selector function.
- *
- * The selector function will get re-evaluated any time something changes in
- * Storage. The value returned by your selector function will also be the
- * value returned by the hook.
- *
- * The `root` value that gets passed to your selector function is
- * a immutable/readonly version of your Liveblocks storage root.
- *
- * The component that uses this hook will automatically re-render if the
- * returned value changes.
- *
- * By default `useStorage()` uses strict `===` to check for equality. Take
- * extra care when returning a computed object or list, for example when you
- * return the result of a .map() or .filter() call from the selector. In
- * those cases, you'll probably want to use a `shallow` comparison check.
- */
-declare const _useStorage: TypedBundle["useStorage"];
-/**
- * Extract arbitrary data from the Liveblocks Storage state, using an
- * arbitrary selector function.
- *
- * The selector function will get re-evaluated any time something changes in
- * Storage. The value returned by your selector function will also be the
- * value returned by the hook.
- *
- * The `root` value that gets passed to your selector function is
- * a immutable/readonly version of your Liveblocks storage root.
- *
- * The component that uses this hook will automatically re-render if the
- * returned value changes.
- *
- * By default `useStorage()` uses strict `===` to check for equality. Take
- * extra care when returning a computed object or list, for example when you
- * return the result of a .map() or .filter() call from the selector. In
- * those cases, you'll probably want to use a `shallow` comparison check.
- */
-declare const _useStorageSuspense: TypedBundle["suspense"]["useStorage"];
-/**
- * Gets the current user once it is connected to the room.
- *
- * @example
- * const me = useSelf();
- * if (me !== null) {
- *   const { x, y } = me.presence.cursor;
- * }
- */
-declare function _useSelf(): User<DP, DU> | null;
-/**
- * Extract arbitrary data based on the current user.
- *
- * The selector function will get re-evaluated any time your presence data
- * changes.
- *
- * The component that uses this hook will automatically re-render if your
- * selector function returns a different value from its previous run.
- *
- * By default `useSelf()` uses strict `===` to check for equality. Take extra
- * care when returning a computed object or list, for example when you return
- * the result of a .map() or .filter() call from the selector. In those
- * cases, you'll probably want to use a `shallow` comparison check.
- *
- * Will return `null` while Liveblocks isn't connected to a room yet.
- *
- * @example
- * const cursor = useSelf(me => me.presence.cursor);
- * if (cursor !== null) {
- *   const { x, y } = cursor;
- * }
- *
- */
-declare function _useSelf<T>(selector: (me: User<DP, DU>) => T, isEqual?: (prev: T, curr: T) => boolean): T | null;
-/**
- * Gets the current user once it is connected to the room.
- *
- * @example
- * const me = useSelf();
- * const { x, y } = me.presence.cursor;
- */
-declare function _useSelfSuspense(): User<DP, DU>;
-/**
- * Extract arbitrary data based on the current user.
- *
- * The selector function will get re-evaluated any time your presence data
- * changes.
- *
- * The component that uses this hook will automatically re-render if your
- * selector function returns a different value from its previous run.
- *
- * By default `useSelf()` uses strict `===` to check for equality. Take extra
- * care when returning a computed object or list, for example when you return
- * the result of a .map() or .filter() call from the selector. In those
- * cases, you'll probably want to use a `shallow` comparison check.
- *
- * @example
- * const cursor = useSelf(me => me.presence.cursor);
- * const { x, y } = cursor;
- *
- */
-declare function _useSelfSuspense<T>(selector: (me: User<DP, DU>) => T, isEqual?: (prev: T, curr: T) => boolean): T;
-/**
- * Returns the mutable (!) Storage root. This hook exists for
- * backward-compatible reasons.
- *
- * @example
- * const [root] = useStorageRoot();
- */
-declare const _useStorageRoot: TypedBundle["useStorageRoot"];
-/**
- * useUpdateMyPresence is similar to useMyPresence but it only returns the function to update the current user presence.
- * If you don't use the current user presence in your component, but you need to update it (e.g. live cursor), it's better to use useUpdateMyPresence to avoid unnecessary renders.
- *
- * @example
- * const updateMyPresence = useUpdateMyPresence();
- * updateMyPresence({ x: 0 });
- * updateMyPresence({ y: 0 });
- *
- * // At the next render, the presence of the current user will be equal to "{ x: 0, y: 0 }"
- */
-declare const _useUpdateMyPresence: TypedBundle["useUpdateMyPresence"];
+declare const _useUserThreadsSuspense_experimental: TypedBundle["suspense"]["useUserThreads_experimental"];
 
-export { useOthersConnectionIds as $, _useIsInsideRoom as A, useLostConnectionListener as B, ClientSideSuspense as C, useMarkThreadAsRead as D, _useMutation as E, _useMyPresence as F, _useOthersListener as G, useRedo as H, useRemoveReaction as I, _useRoom as J, useRoomNotificationSettings as K, LiveblocksProvider as L, type MutationContext as M, useStatus as N, _useStorageRoot as O, useThreadSubscription as P, useUndo as Q, RoomContext as R, _useUpdateMyPresence as S, useUpdateRoomNotificationSettings as T, type UseStorageStatusOptions as U, useHistoryVersionData as V, useCommentsErrorListener as W, CreateThreadError as X, _useOther as Y, _useOthers as Z, _useInboxNotificationThread as _, type UseThreadsOptions as a, _useOthersMapped as a0, _useSelf as a1, _useStorage as a2, useStorageStatus as a3, _useThreads as a4, useAttachmentUrl as a5, _useHistoryVersions as a6, useInboxNotifications as a7, _useUserThreads_experimental as a8, useRoomInfo as a9, useUnreadInboxNotificationsCount as aa, _useUser as ab, getUmbrellaStoreForClient as ac, selectThreads as ad, _useOtherSuspense as ae, _useOthersSuspense as af, useOthersConnectionIdsSuspense as ag, _useOthersMappedSuspense as ah, _useSelfSuspense as ai, _useStorageSuspense as aj, useStorageStatusSuspense as ak, _useThreadsSuspense as al, useAttachmentUrlSuspense as am, _useHistoryVersionsSuspense as an, useInboxNotificationsSuspense as ao, useRoomInfoSuspense as ap, useUnreadInboxNotificationsCountSuspense as aq, _useUserSuspense as ar, _useUserThreadsSuspense_experimental as as, ClientContext as b, createLiveblocksContext as c, useMarkAllInboxNotificationsAsRead as d, useMarkInboxNotificationAsRead as e, useDeleteAllInboxNotifications as f, useDeleteInboxNotification as g, createRoomContext as h, _RoomProvider as i, _useAddReaction as j, useBatch as k, _useBroadcastEvent as l, useCanRedo as m, useCanUndo as n, useCreateComment as o, _useCreateThread as p, useDeleteComment as q, _useDeleteThread as r, useEditComment as s, _useEditThreadMetadata as t, useClient as u, useMarkThreadAsResolved as v, useMarkThreadAsUnresolved as w, useErrorListener as x, _useEventListener as y, useHistory as z };
+export { type AttachmentUrlAsyncResult as A, CreateThreadError as C, type DeleteCommentOptions as D, type EditCommentOptions as E, type HistoryVersionDataAsyncResult as H, LiveblocksProvider as L, type MutationContext as M, type RoomContextBundle as R, type StorageStatusSuccess as S, type ThreadSubscription as T, type UseStorageStatusOptions as U, _useInboxNotificationThread as _, type CommentsError as a, type CreateCommentOptions as b, type CommentReactionOptions as c, type UseThreadsOptions as d, ClientContext as e, createLiveblocksContext as f, getUmbrellaStoreForClient as g, useMarkAllInboxNotificationsAsRead as h, useMarkInboxNotificationAsRead as i, useDeleteAllInboxNotifications as j, useDeleteInboxNotification as k, useInboxNotifications as l, _useUserThreads_experimental as m, useRoomInfo as n, useUnreadInboxNotificationsCount as o, _useUser as p, useInboxNotificationsSuspense as q, useRoomInfoSuspense as r, useUnreadInboxNotificationsCountSuspense as s, _useUserSuspense as t, useClient as u, _useUserThreadsSuspense_experimental as v };