@liveblocks/react 2.12.1-test1 → 2.12.1-test2

package/dist/suspense-TeBnnKGw.d.mts

@@ -1,730 +0,0 @@
-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-1ujmr05d.mjs';
-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.
- *
- * @deprecated Prefer useSyncStatus()
- */
-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.
- *
- * @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;
-/**
- * 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 };