@liveblocks/react 2.12.1-emails1 → 2.12.1-test2

package/dist/{liveblocks-1ujmr05d.d.ts → room-t_BUxm1-.d.ts}

@@ -1,5 +1,7 @@
-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, SyncStatus, LiveblocksError, RoomEventMessage, CommentData, PartialUnless, ThreadDataWithDeleteInfo, OpaqueClient, CommentUserReaction, ThreadDeleteInfo, InboxNotificationDeleteInfo, RoomNotificationSettings as RoomNotificationSettings$1, DistributiveOmit, DU, DM } from '@liveblocks/core';
+import { JsonObject, LsonObject, BaseUserMeta, LiveObject, User, Json, RoomNotificationSettings, Room, Status, BroadcastOptions, OthersEvent, LostConnectionEvent, History, BaseMetadata as BaseMetadata$1, Client as Client$1, ClientOptions, StorageStatus as StorageStatus$1, ThreadData as ThreadData$1, CommentData as CommentData$1 } from '@liveblocks/client';
+import * as _liveblocks_core from '@liveblocks/core';
+import { BaseMetadata, CommentBody, Patchable, StorageStatus, QueryMetadata, AsyncResult, DRI, AsyncSuccess, Resolve, CommentAttachment, PartialUnless, InboxNotificationData, ToImmutable, AsyncLoading, AsyncError, ThreadData, HistoryVersion, Client, SyncStatus, LiveblocksError, RoomEventMessage, CommentData, ThreadDataWithDeleteInfo, OpaqueClient, Permission, CommentUserReaction, ThreadDeleteInfo, InboxNotificationDeleteInfo, RoomNotificationSettings as RoomNotificationSettings$1, DistributiveOmit, DU, DM, OpaqueRoom, DP, DS, DE } from '@liveblocks/core';
+import * as React$1 from 'react';
 import React__default, { PropsWithChildren } from 'react';
 
 /**
@@ -1330,6 +1332,7 @@ declare class UmbrellaStore<M extends BaseMetadata> {
     getNotificationSettingsLoadingState(roomId: string): RoomNotificationSettingsAsyncResult;
     getRoomVersionsLoadingState(roomId: string): AsyncResult<HistoryVersion[], "versions">;
     subscribe(callback: () => void): () => void;
+    _getPermissions(roomId: string): Set<Permission> | undefined;
     private mutateThreadsDB;
     private updateInboxNotificationsCache;
     private setNotificationSettings;
@@ -1407,6 +1410,7 @@ declare class UmbrellaStore<M extends BaseMetadata> {
     removeOptimisticUpdate(optimisticUpdateId: string): void;
     fetchNotificationsDeltaUpdate(signal: AbortSignal): Promise<void>;
     waitUntilNotificationsLoaded(): UsablePromise<void>;
+    private updateRoomPermissions;
     waitUntilRoomThreadsLoaded(roomId: string, query: ThreadsQuery<M> | undefined): UsablePromise<void>;
     fetchRoomThreadsDeltaUpdate(roomId: string, signal: AbortSignal): Promise<void>;
     waitUntilUserThreadsLoaded(query: ThreadsQuery<M> | undefined): UsablePromise<void>;
@@ -1535,7 +1539,7 @@ declare function useRoomInfo(roomId: string): RoomInfoAsyncResult;
  * const { info } = useRoomInfo("room-id");
  */
 declare function useRoomInfoSuspense(roomId: string): RoomInfoAsyncSuccess;
-declare type TypedBundle = LiveblocksContextBundle<DU, DM>;
+declare type TypedBundle$1 = LiveblocksContextBundle<DU, DM>;
 /**
  * Returns the thread associated with a `"thread"` inbox notification.
  *
@@ -1551,21 +1555,21 @@ declare type TypedBundle = LiveblocksContextBundle<DU, DM>;
  * @example
  * const thread = useInboxNotificationThread("in_xxx");
  */
-declare const _useInboxNotificationThread: TypedBundle["useInboxNotificationThread"];
+declare const _useInboxNotificationThread: TypedBundle$1["useInboxNotificationThread"];
 /**
  * Returns user info from a given user ID.
  *
  * @example
  * const { user, error, isLoading } = useUser("user-id");
  */
-declare const _useUser: TypedBundle["useUser"];
+declare const _useUser: TypedBundle$1["useUser"];
 /**
  * Returns user info from a given user ID.
  *
  * @example
  * const { user } = useUser("user-id");
  */
-declare const _useUserSuspense: TypedBundle["suspense"]["useUser"];
+declare const _useUserSuspense: TypedBundle$1["suspense"]["useUser"];
 /**
  * @experimental
  *
@@ -1581,7 +1585,7 @@ declare const _useUserSuspense: TypedBundle["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["useUserThreads_experimental"];
+declare const _useUserThreads_experimental: TypedBundle$1["useUserThreads_experimental"];
 /**
  * @experimental
  *
@@ -1597,7 +1601,7 @@ declare const _useUserThreads_experimental: TypedBundle["useUserThreads_experime
  * 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["suspense"]["useUserThreads_experimental"];
+declare const _useUserThreadsSuspense_experimental: TypedBundle$1["suspense"]["useUserThreads_experimental"];
 /**
  * Returns the current Liveblocks sync status, and triggers a re-render
  * whenever it changes. Can be used to render a "Saving..." indicator, or for
@@ -1610,4 +1614,752 @@ declare const _useUserThreadsSuspense_experimental: TypedBundle["suspense"]["use
  */
 declare function useSyncStatus(options?: UseSyncStatusOptions): SyncStatus;
 
-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, useDeleteAllInboxNotifications as h, useDeleteInboxNotification as i, useMarkAllInboxNotificationsAsRead as j, useMarkInboxNotificationAsRead as k, useSyncStatus as l, useInboxNotifications as m, _useUserThreads_experimental as n, useRoomInfo as o, useUnreadInboxNotificationsCount as p, _useUser as q, useInboxNotificationsSuspense as r, useRoomInfoSuspense as s, useUnreadInboxNotificationsCountSuspense as t, useClient as u, _useUserSuspense as v, _useUserThreadsSuspense_experimental as w };
+/**
+ * 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>;
+/** @private */
+declare function useRoomOrNull<P extends JsonObject, S extends LsonObject, U extends BaseUserMeta, E extends Json, M extends BaseMetadata$1>(): Room<P, S, U, E, M> | 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.
+ *
+ * @deprecated Prefer useSyncStatus()
+ */
+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;
+/**
+ * @private
+ */
+declare function useCreateRoomThread<M extends BaseMetadata$1>(roomId: string): (options: CreateThreadOptions<M>) => ThreadData$1<M>;
+declare function useDeleteRoomThread(roomId: string): (threadId: string) => void;
+declare function useEditRoomThreadMetadata<M extends BaseMetadata$1>(roomId: string): (options: EditThreadMetadataOptions<M>) => 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;
+/**
+ * @private
+ */
+declare function useCreateRoomComment(roomId: string): (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;
+/**
+ * @private
+ */
+declare function useEditRoomComment(roomId: string): (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;
+/**
+ * @private
+ */
+declare function useDeleteRoomComment(roomId: string): ({ threadId, commentId }: DeleteCommentOptions) => void;
+/**
+ * @private
+ */
+declare function useAddRoomCommentReaction<M extends BaseMetadata$1>(roomId: string): ({ threadId, commentId, emoji }: CommentReactionOptions) => 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;
+/**
+ * @private
+ */
+declare function useRemoveRoomCommentReaction(roomId: string): ({ 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;
+/**
+ * @private
+ */
+declare function useMarkRoomThreadAsRead(roomId: string): (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;
+/**
+ * @private
+ */
+declare function useMarkRoomThreadAsResolved(roomId: string): (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;
+/**
+ * @private
+ */
+declare function useMarkRoomThreadAsUnresolved(roomId: string): (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 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.
+ *
+ * @deprecated Prefer useSyncStatus()
+ */
+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;
+/**
+ * @private For internal use only. Do not rely on this hook. Use `useAttachmentUrl` instead.
+ */
+declare function useRoomAttachmentUrl(attachmentId: string, roomId: 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;
+};
+/**
+ * @private For internal use only. Do not rely on this hook.
+ */
+declare function useRoomPermissions(roomId: string): Set<_liveblocks_core.Permission>;
+/**
+ * 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"];
+/**
+ * Returns the user's notification settings for the current room
+ * and a function to update them.
+ *
+ * @example
+ * const [{ settings }, updateSettings] = useRoomNotificationSettings();
+ */
+declare const _useRoomNotificationSettings: TypedBundle["useRoomNotificationSettings"];
+/**
+ * Returns the user's notification settings for the current room
+ * and a function to update them.
+ *
+ * @example
+ * const [{ settings }, updateSettings] = useRoomNotificationSettings();
+ */
+declare const _useRoomNotificationSettingsSuspense: TypedBundle["suspense"]["useRoomNotificationSettings"];
+/**
+ * (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"];
+
+export { _useOthersListener as $, _useAddReaction as A, useBatch as B, CreateThreadError as C, _useBroadcastEvent as D, useCanRedo as E, useCanUndo as F, useCreateComment as G, _useCreateThread as H, useDeleteComment as I, _useDeleteThread as J, useEditComment as K, LiveblocksProvider as L, type MutationContext as M, _useEditThreadMetadata as N, useMarkThreadAsResolved as O, useMarkThreadAsUnresolved as P, useErrorListener as Q, RoomContext as R, _useEventListener as S, useHistory as T, type UseStorageStatusOptions as U, _useIsInsideRoom as V, useLostConnectionListener as W, useMarkThreadAsRead as X, _useMutation as Y, _useMyPresence as Z, _useInboxNotificationThread as _, useAddRoomCommentReaction as a, useRedo as a0, useRemoveReaction as a1, _useRoom as a2, useStatus as a3, _useStorageRoot as a4, useThreadSubscription as a5, useUndo as a6, _useUpdateMyPresence as a7, useUpdateRoomNotificationSettings as a8, useHistoryVersionData as a9, _useHistoryVersionsSuspense as aA, _useRoomNotificationSettingsSuspense as aB, useInboxNotificationsSuspense as aC, useRoomInfoSuspense as aD, useUnreadInboxNotificationsCountSuspense as aE, _useUserSuspense as aF, _useUserThreadsSuspense_experimental as aG, useCommentsErrorListener as aa, _useOther as ab, _useOthers as ac, useOthersConnectionIds as ad, _useOthersMapped as ae, _useSelf as af, _useStorage as ag, useStorageStatus as ah, _useThreads as ai, useAttachmentUrl as aj, _useHistoryVersions as ak, _useRoomNotificationSettings as al, useInboxNotifications as am, _useUserThreads_experimental as an, useRoomInfo as ao, useUnreadInboxNotificationsCount as ap, _useUser as aq, _useOtherSuspense as ar, _useOthersSuspense as as, useOthersConnectionIdsSuspense as at, _useOthersMappedSuspense as au, _useSelfSuspense as av, _useStorageSuspense as aw, useStorageStatusSuspense as ax, _useThreadsSuspense as ay, useAttachmentUrlSuspense as az, useCreateRoomComment as b, useCreateRoomThread as c, useDeleteRoomComment as d, useDeleteRoomThread as e, useEditRoomComment as f, getUmbrellaStoreForClient as g, useEditRoomThreadMetadata as h, useMarkRoomThreadAsRead as i, useMarkRoomThreadAsResolved as j, useMarkRoomThreadAsUnresolved as k, useRemoveRoomCommentReaction as l, useRoomAttachmentUrl as m, useRoomPermissions as n, type UseThreadsOptions as o, ClientContext as p, createLiveblocksContext as q, useClient as r, useDeleteAllInboxNotifications as s, useDeleteInboxNotification as t, useRoomOrNull as u, useMarkAllInboxNotificationsAsRead as v, useMarkInboxNotificationAsRead as w, useSyncStatus as x, createRoomContext as y, _RoomProvider as z };