@liveblocks/react 2.0.5 → 2.1.1-test1

package/dist/{suspense-72By2Jmd.d.mts → suspense-qP2VFyHd.d.mts}

@@ -1,7 +1,7 @@
 import * as React$1 from 'react';
 import React__default, { ReactNode, PropsWithChildren } from 'react';
 import { JsonObject, LsonObject, BaseUserMeta, LiveObject, User, Json, RoomNotificationSettings, Room, Status, BroadcastOptions, OthersEvent, LostConnectionEvent, History, Client, BaseMetadata as BaseMetadata$1 } from '@liveblocks/client';
-import { BaseMetadata, CommentBody, Patchable, QueryMetadata, DRI, InboxNotificationData, Resolve, ToImmutable, ThreadData, LiveblocksError, RoomEventMessage, CommentData, PartialUnless, OpaqueClient, DU, ClientOptions, DM, OpaqueRoom, RoomNotificationSettings as RoomNotificationSettings$1, DP, DS, DE } from '@liveblocks/core';
+import { BaseMetadata, CommentBody, Patchable, QueryMetadata, StorageStatus, DRI, InboxNotificationData, Resolve, ToImmutable, ThreadData, LiveblocksError, RoomEventMessage, CommentData, PartialUnless, OpaqueClient, DU, ClientOptions, DM, OpaqueRoom, RoomNotificationSettings as RoomNotificationSettings$1, DP, DS, DE } from '@liveblocks/core';
 
 declare type Props = {
     fallback: ReactNode;
@@ -26,6 +26,9 @@ declare type Props = {
  */
 declare function ClientSideSuspense(props: Props): React$1.JSX.Element;
 
+/**
+ * @private Internal API, do not rely on it.
+ */
 declare class CreateThreadError<M extends BaseMetadata> extends Error {
     cause: Error;
     context: {
@@ -119,6 +122,7 @@ declare class UpdateNotificationSettingsError extends Error {
 }
 declare type CommentsError<M extends BaseMetadata> = CreateThreadError<M> | EditThreadMetadataError<M> | CreateCommentError | EditCommentError | DeleteCommentError | MarkInboxNotificationAsReadError | UpdateNotificationSettingsError;
 
+declare type StorageStatusSuccess = Exclude<StorageStatus, "not-loaded" | "loading">;
 declare type UseThreadsOptions<M extends BaseMetadata> = {
     /**
      * The query (including metadata) to filter the threads by. If provided, only threads
@@ -461,8 +465,13 @@ declare type RoomContextBundleCommon<P extends JsonObject, S extends LsonObject,
      * 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(({ connectionId, event }) => {
+     * useEventListener(({ event, user, connectionId }) => {
+     * //                         ^^^^ Will be Client A
      *   if (event.type === "CUSTOM_EVENT") {
      *     // Do something
      *   }
@@ -537,10 +546,9 @@ declare type RoomContextBundleCommon<P extends JsonObject, S extends LsonObject,
      * The first argument that gets passed into your callback will be
      * a "mutation context", which exposes the following:
      *
-     *   - `root` - The mutable Storage root.
-     *              You can normal mutation on Live structures with this, for
-     *              example: root.get('layers').get('layer1').set('fill',
-     *              'red')
+     *   - `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.
      *
@@ -554,11 +562,11 @@ declare type RoomContextBundleCommon<P extends JsonObject, S extends LsonObject,
      * 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 `root.ToImmutable()`.
+     * you can use `storage.ToImmutable()`.
      *
      * @example
      * const fillLayers = useMutation(
-     *   ({ root }, color: Color) => {
+     *   ({ storage }, color: Color) => {
      *     ...
      *   },
      *   [],
@@ -567,7 +575,7 @@ declare type RoomContextBundleCommon<P extends JsonObject, S extends LsonObject,
      * fillLayers('red');
      *
      * const deleteLayers = useMutation(
-     *   ({ root }) => {
+     *   ({ storage }) => {
      *     ...
      *   },
      *   [],
@@ -577,8 +585,8 @@ declare type RoomContextBundleCommon<P extends JsonObject, S extends LsonObject,
      */
     useMutation<F extends (context: MutationContext<P, S, U>, ...args: any[]) => any>(callback: F, deps: readonly unknown[]): OmitFirstArg<F>;
     /**
-     * Returns an object that lets you get information about all the users
-     * currently connected in the room.
+     * Returns an array with information about all the users currently connected
+     * in the room (except yourself).
      *
      * @example
      * const others = useOthers();
@@ -773,6 +781,12 @@ declare type PrivateRoomContextApi = {
     useCommentsErrorListener<M extends BaseMetadata>(callback: (err: CommentsError<M>) => void): void;
 };
 declare type RoomContextBundle<P extends JsonObject, S extends LsonObject, U extends BaseUserMeta, E extends Json, M extends BaseMetadata> = Resolve<RoomContextBundleCommon<P, S, U, E, M> & SharedContextBundle<U>["classic"] & {
+    /**
+     * Returns the current storage status for the Room, and triggers
+     * a re-render whenever it changes. Can be used to render a "Saving..."
+     * indicator.
+     */
+    useStorageStatus(): StorageStatus;
     /**
      * Extract arbitrary data from the Liveblocks Storage state, using an
      * arbitrary selector function.
@@ -798,7 +812,9 @@ declare type RoomContextBundle<P extends JsonObject, S extends LsonObject, U ext
      *
      * @example
      * const me = useSelf();
-     * const { x, y } = me.presence.cursor;
+     * if (me !== null) {
+     *   const { x, y } = me.presence.cursor;
+     * }
      */
     useSelf(): User<P, U> | null;
     /**
@@ -846,6 +862,12 @@ declare type RoomContextBundle<P extends JsonObject, S extends LsonObject, U ext
         (settings: Partial<RoomNotificationSettings>) => void
     ];
     suspense: Resolve<RoomContextBundleCommon<P, S, U, E, M> & SharedContextBundle<U>["suspense"] & {
+        /**
+         * Returns the current storage status for the Room, and triggers
+         * a re-render whenever it changes. Can be used to render a "Saving..."
+         * indicator.
+         */
+        useStorageStatus(): StorageStatusSuccess;
         /**
          * Extract arbitrary data from the Liveblocks Storage state, using an
          * arbitrary selector function.
@@ -888,13 +910,9 @@ declare type RoomContextBundle<P extends JsonObject, S extends LsonObject, U ext
          * 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;
-         * }
+         * const { x, y } = cursor;
          *
          */
         useSelf<T>(selector: (me: User<P, U>) => T, isEqual?: (prev: T, curr: T) => boolean): T;
@@ -1000,6 +1018,12 @@ declare type LiveblocksContextBundle<U extends BaseUserMeta, M extends BaseMetad
     }>;
 }>;
 
+/**
+ * Raw access to the React context where the LiveblocksProvider stores the
+ * current client. Exposed for advanced use cases only.
+ *
+ * @private This is a private/advanced API. Do not rely on it.
+ */
 declare const ClientContext: React__default.Context<OpaqueClient | null>;
 /**
  * Obtains a reference to the current Liveblocks client.
@@ -1014,69 +1038,737 @@ declare function useClient<U extends BaseUserMeta>(): Client<U>;
  * and it should be placed higher in your app’s component tree.
  */
 declare function LiveblocksProvider<U extends BaseUserMeta = DU>(props: PropsWithChildren<ClientOptions<U>>): React__default.JSX.Element;
+/**
+ * Creates a LiveblocksProvider and a set of typed hooks. Note that any
+ * LiveblocksProvider created in this way takes no props, because it uses
+ * settings from the given client instead.
+ */
 declare function createLiveblocksContext<U extends BaseUserMeta = DU, M extends BaseMetadata$1 = DM>(client: OpaqueClient): LiveblocksContextBundle<U, M>;
+/**
+ * @beta
+ *
+ * Returns the inbox notifications for the current user.
+ *
+ * @example
+ * const { inboxNotifications, error, isLoading } = useInboxNotifications();
+ */
 declare function useInboxNotifications(): InboxNotificationsState;
+/**
+ * @beta
+ *
+ * Returns the inbox notifications for the current user.
+ *
+ * @example
+ * const { inboxNotifications } = useInboxNotifications();
+ */
 declare function useInboxNotificationsSuspense(): InboxNotificationsStateSuccess;
+/**
+ * @beta
+ *
+ * Returns a function that marks all inbox notifications as read.
+ *
+ * @example
+ * const markAllInboxNotificationsAsRead = useMarkAllInboxNotificationsAsRead();
+ * markAllInboxNotificationsAsRead();
+ */
 declare function useMarkAllInboxNotificationsAsRead(): () => void;
+/**
+ * @beta
+ *
+ * Returns a function that marks an inbox notification as read.
+ *
+ * @example
+ * const markInboxNotificationAsRead = useMarkInboxNotificationAsRead();
+ * markInboxNotificationAsRead("in_xxx");
+ */
 declare function useMarkInboxNotificationAsRead(): (inboxNotificationId: string) => void;
+/**
+ * @beta
+ *
+ * Returns the number of unread inbox notifications for the current user.
+ *
+ * @example
+ * const { count, error, isLoading } = useUnreadInboxNotificationsCount();
+ */
 declare function useUnreadInboxNotificationsCount(): UnreadInboxNotificationsCountState;
+/**
+ * @beta
+ *
+ * Returns the number of unread inbox notifications for the current user.
+ *
+ * @example
+ * const { count } = useUnreadInboxNotificationsCount();
+ */
 declare function useUnreadInboxNotificationsCountSuspense(): UnreadInboxNotificationsCountStateSuccess;
+/**
+ * Returns room info from a given room ID.
+ *
+ * @example
+ * const { info, error, isLoading } = useRoomInfo("room-id");
+ */
 declare function useRoomInfo(roomId: string): RoomInfoState;
+/**
+ * Returns room info from a given room ID.
+ *
+ * @example
+ * const { info } = useRoomInfo("room-id");
+ */
 declare function useRoomInfoSuspense(roomId: string): RoomInfoStateSuccess;
-declare const __1: LiveblocksContextBundle<DU, DM>["useInboxNotificationThread"];
-declare const __2: LiveblocksContextBundle<DU, DM>["useUser"];
-declare const __3: LiveblocksContextBundle<DU, DM>["suspense"]["useUser"];
+declare type TypedBundle$1 = LiveblocksContextBundle<DU, DM>;
+/**
+ * @beta
+ *
+ * Returns the thread associated with a `"thread"` inbox notification.
+ *
+ * @example
+ * const thread = useInboxNotificationThread("in_xxx");
+ */
+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$1["useUser"];
+/**
+ * Returns user info from a given user ID.
+ *
+ * @example
+ * const { user } = useUser("user-id");
+ */
+declare const _useUserSuspense: TypedBundle$1["suspense"]["useUser"];
 
+/**
+ * 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(): StorageStatus;
+/**
+ * @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;
+/**
+ * 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 the subscription status of a thread.
+ *
+ * @example
+ * const { status, unreadSince } = useThreadSubscription("th_xxx");
+ */
 declare function useThreadSubscription(threadId: string): ThreadSubscription;
+/**
+ * @beta
+ *
+ * Returns the user's notification settings for the current room
+ * and a function to update them.
+ *
+ * @example
+ * const [{ settings }, updateSettings] = useRoomNotificationSettings();
+ */
 declare function useRoomNotificationSettings(): [
     RoomNotificationSettingsState,
     (settings: Partial<RoomNotificationSettings$1>) => void
 ];
+/**
+ * @beta
+ *
+ * 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$1>) => 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(): StorageStatusSuccess;
+/**
+ * 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 DefaultRoomContextBundle = RoomContextBundle<DP, DS, DU, DE, DM>;
-declare const _RoomProvider: DefaultRoomContextBundle["RoomProvider"];
-declare const _useBroadcastEvent: DefaultRoomContextBundle["useBroadcastEvent"];
-declare const _useOthersListener: DefaultRoomContextBundle["useOthersListener"];
-declare const _useRoom: DefaultRoomContextBundle["useRoom"];
-declare const _useAddReaction: DefaultRoomContextBundle["useAddReaction"];
-declare const _useMutation: DefaultRoomContextBundle["useMutation"];
-declare const _useCreateThread: DefaultRoomContextBundle["useCreateThread"];
-declare const _useDeleteThread: DefaultRoomContextBundle["useDeleteThread"];
-declare const _useEditThreadMetadata: DefaultRoomContextBundle["useEditThreadMetadata"];
-declare const _useEventListener: DefaultRoomContextBundle["useEventListener"];
-declare const _useMyPresence: DefaultRoomContextBundle["useMyPresence"];
-declare const _useOthersMapped: DefaultRoomContextBundle["useOthersMapped"];
-declare const _useOthersMappedSuspense: DefaultRoomContextBundle["suspense"]["useOthersMapped"];
-declare const _useThreads: DefaultRoomContextBundle["useThreads"];
-declare const _useThreadsSuspense: DefaultRoomContextBundle["suspense"]["useThreads"];
-declare const _useOther: DefaultRoomContextBundle["useOther"];
-declare const _useOthers: DefaultRoomContextBundle["useOthers"];
-declare const _useOtherSuspense: DefaultRoomContextBundle["suspense"]["useOther"];
-declare const _useOthersSuspense: DefaultRoomContextBundle["suspense"]["useOthers"];
-declare const _useStorage: DefaultRoomContextBundle["useStorage"];
-declare const _useStorageSuspense: DefaultRoomContextBundle["suspense"]["useStorage"];
-declare const _useSelf: DefaultRoomContextBundle["useSelf"];
-declare const _useSelfSuspense: DefaultRoomContextBundle["suspense"]["useSelf"];
-declare const _useStorageRoot: DefaultRoomContextBundle["useStorageRoot"];
-declare const _useUpdateMyPresence: DefaultRoomContextBundle["useUpdateMyPresence"];
+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 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"];
+/**
+ * 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 { useUnreadInboxNotificationsCount as $, useRedo as A, useRemoveReaction as B, ClientSideSuspense as C, _useRoom as D, useRoomNotificationSettings as E, useStatus as F, _useStorageRoot as G, useThreadSubscription as H, useUndo as I, _useUpdateMyPresence as J, useUpdateRoomNotificationSettings as K, LiveblocksProvider as L, type MutationContext as M, useCommentsErrorListener as N, CreateThreadError as O, _useOther as P, _useOthers as Q, RoomContext as R, useOthersConnectionIds as S, _useOthersMapped as T, type UseThreadsOptions as U, _useSelf as V, _useStorage as W, _useThreads as X, useInboxNotifications as Y, useRoomInfo as Z, __1 as _, ClientContext as a, __2 as a0, _useOtherSuspense as a1, _useOthersSuspense as a2, useOthersConnectionIdsSuspense as a3, _useOthersMappedSuspense as a4, _useSelfSuspense as a5, _useStorageSuspense as a6, _useThreadsSuspense as a7, useInboxNotificationsSuspense as a8, useRoomInfoSuspense as a9, useUnreadInboxNotificationsCountSuspense as aa, __3 as ab, useMarkAllInboxNotificationsAsRead as b, createLiveblocksContext as c, useMarkInboxNotificationAsRead as d, createRoomContext as e, _RoomProvider as f, _useAddReaction as g, useBatch as h, _useBroadcastEvent as i, useCanRedo as j, useCanUndo as k, useCreateComment as l, _useCreateThread as m, _useDeleteThread as n, useDeleteComment as o, useEditComment as p, _useEditThreadMetadata as q, useErrorListener as r, _useEventListener as s, useHistory as t, useClient as u, useLostConnectionListener as v, useMarkThreadAsRead as w, _useMutation as x, _useMyPresence as y, _useOthersListener as z };
+export { useRoomInfo as $, useRedo as A, useRemoveReaction as B, ClientSideSuspense as C, _useRoom as D, useRoomNotificationSettings as E, useStatus as F, _useStorageRoot as G, useThreadSubscription as H, useUndo as I, _useUpdateMyPresence as J, useUpdateRoomNotificationSettings as K, LiveblocksProvider as L, type MutationContext as M, useCommentsErrorListener as N, CreateThreadError as O, _useOther as P, _useOthers as Q, RoomContext as R, useOthersConnectionIds as S, _useOthersMapped as T, type UseThreadsOptions as U, _useSelf as V, _useStorage as W, useStorageStatus as X, _useThreads as Y, useInboxNotifications as Z, _useInboxNotificationThread as _, ClientContext as a, useUnreadInboxNotificationsCount as a0, _useUser as a1, _useOtherSuspense as a2, _useOthersSuspense as a3, useOthersConnectionIdsSuspense as a4, _useOthersMappedSuspense as a5, _useSelfSuspense as a6, _useStorageSuspense as a7, useStorageStatusSuspense as a8, _useThreadsSuspense as a9, useInboxNotificationsSuspense as aa, useRoomInfoSuspense as ab, useUnreadInboxNotificationsCountSuspense as ac, _useUserSuspense as ad, useMarkAllInboxNotificationsAsRead as b, createLiveblocksContext as c, useMarkInboxNotificationAsRead as d, createRoomContext as e, _RoomProvider as f, _useAddReaction as g, useBatch as h, _useBroadcastEvent as i, useCanRedo as j, useCanUndo as k, useCreateComment as l, _useCreateThread as m, useDeleteComment as n, _useDeleteThread as o, useEditComment as p, _useEditThreadMetadata as q, useErrorListener as r, _useEventListener as s, useHistory as t, useClient as u, useLostConnectionListener as v, useMarkThreadAsRead as w, _useMutation as x, _useMyPresence as y, _useOthersListener as z };