@liveblocks/react 2.9.3-experimental1 → 2.10.1-react19

package/dist/suspense-W7Cp9ygn.d.ts

@@ -0,0 +1,726 @@
+import { U as UseStorageStatusOptions, a as CommentsError, b as CreateCommentOptions, E as EditCommentOptions, D as DeleteCommentOptions, c as CommentReactionOptions, T as ThreadSubscription, H as HistoryVersionDataAsyncResult, S as StorageStatusSuccess, A as AttachmentUrlAsyncResult, R as RoomContextBundle } from './liveblocks-SAVcXwMX.js';
+import { Status, StorageStatus, LostConnectionEvent, History, BaseMetadata, CommentData, RoomNotificationSettings, JsonObject, LsonObject, BaseUserMeta, Json, User } from '@liveblocks/client';
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { OpaqueRoom, LiveblocksError, DP, DS, DU, DE, DM, OpaqueClient } 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.JSX.Element;
+
+/**
+ * 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.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;
+/**
+ * @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>(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 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 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 = 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 { _useStorageSuspense as $, useStatus as A, _useStorageRoot as B, ClientSideSuspense as C, useThreadSubscription as D, useUndo as E, _useUpdateMyPresence as F, useUpdateRoomNotificationSettings as G, useHistoryVersionData as H, useCommentsErrorListener as I, _useOther as J, _useOthers as K, useOthersConnectionIds as L, _useOthersMapped as M, _useSelf as N, _useStorage as O, useStorageStatus as P, _useThreads as Q, RoomContext as R, useAttachmentUrl as S, _useHistoryVersions as T, _useRoomNotificationSettings as U, _useOtherSuspense as V, _useOthersSuspense as W, useOthersConnectionIdsSuspense as X, _useOthersMappedSuspense as Y, _useSelfSuspense as Z, _RoomProvider as _, _useAddReaction as a, useStorageStatusSuspense as a0, _useThreadsSuspense as a1, useAttachmentUrlSuspense as a2, _useHistoryVersionsSuspense as a3, _useRoomNotificationSettingsSuspense as a4, _useBroadcastEvent as b, createRoomContext as c, useCanRedo as d, useCanUndo as e, useCreateComment as f, _useCreateThread as g, useDeleteComment as h, _useDeleteThread as i, useEditComment as j, _useEditThreadMetadata as k, useMarkThreadAsResolved as l, useMarkThreadAsUnresolved as m, useErrorListener as n, _useEventListener as o, useHistory as p, _useIsInsideRoom as q, useLostConnectionListener as r, useMarkThreadAsRead as s, _useMutation as t, useBatch as u, _useMyPresence as v, _useOthersListener as w, useRedo as x, useRemoveReaction as y, _useRoom as z };