@factorialco/f0-react 7.33.0 → 7.35.0

package/dist/experimental.d.ts

@@ -1682,9 +1682,18 @@ declare interface BreakType {
 }
 
 /**
- * Flattens the roster into tiles, preserving the host's participant order.
+ * Flattens the roster into tiles: shares, then everyone else, then you.
+ *
  * Screen shares come first so they are never pushed off the visible page by a
- * long roster.
+ * long roster — your own included, because when you share, what you are
+ * sharing is the thing the room is looking at.
+ *
+ * YOUR CAMERA GOES LAST, and it is the one place the host's order is not
+ * preserved. Without it a one-to-one traded sides: the spotlight rule puts the
+ * other person on the left, while the plain grid took the roster order, which
+ * puts you first — so pinning and unpinning swapped the two of you over. Two
+ * rules ordering the same room. This is the rule they now share, and it reads
+ * the same way everywhere: the people you are talking to lead, you follow.
  */
 export declare const buildTiles: (participants: F0MeetingParticipant[]) => F0MeetingTile[];
 
@@ -5962,6 +5971,11 @@ declare const defaultTranslations: {
         readonly editing: "Editing";
         readonly edited: "edited";
         readonly aiAssisted: "by One";
+        readonly translate: "Translate";
+        readonly hideTranslation: "Hide translation";
+        readonly translated: "Translated";
+        readonly translatedFrom: "Translated from {{language}}";
+        readonly upgrade: "Upgrade";
         readonly cancelEdit: "Cancel edit";
         readonly saveEdit: "Save";
         readonly you: "You";
@@ -6107,12 +6121,15 @@ declare const defaultTranslations: {
         readonly muted: "Muted";
         readonly waitingToJoin: "Waiting…";
         readonly sharingScreen: "Sharing screen";
+        readonly audioRoom: "People in this call";
         readonly chatPanel: "Chat";
         readonly transcriptPanel: "Transcript";
         readonly notesPanel: "Notes";
         readonly openChat: "Open chat";
         readonly closeChat: "Close chat";
         readonly closePanel: "Close panel";
+        readonly resizeChatPanel: "Resize chat panel";
+        readonly chatPanelWidth: "{{width}} pixels";
         readonly notesPlaceholder: "Take notes for everyone in the call…";
         readonly roomChatPlaceholder: "Message this call…";
         readonly roomChatEmpty: "Messages here are only for this call and disappear when it ends.";
@@ -6175,6 +6192,8 @@ declare const defaultTranslations: {
         readonly movedToFloating: "Meeting in a floating window";
         readonly movedToSidePanel: "Meeting in the side panel";
         readonly movedToMinimized: "Meeting minimized";
+        readonly audioOnlyAnnouncement: "Audio only. There is not enough room for video";
+        readonly videoResumed: "Video is back";
         readonly movedInline: "Meeting on the page";
         readonly movedToPictureInPicture: "Meeting in a picture-in-picture window";
     };
@@ -7274,6 +7293,18 @@ declare type ExtractVisualizationSettings<T> = T extends {
     };
 } ? S : never;
 
+/**
+ * WHERE A HOST HANGS SOMETHING OFF THE CONVERSATION'S NAME — a coachmark
+ * explaining a limit, a tour step, a hint. F0 owns the header's markup, so it
+ * owns the promise that there is a stable thing to point at; a host guessing
+ * at class names would break on the next restyle.
+ *
+ * It resolves ONLY once the title has arrived (the skeleton does not carry it),
+ * which is what makes an overlay anchored to it wait for a header worth
+ * pointing at instead of opening over a pulsing grey bar.
+ */
+export declare const F0_CHAT_HEADER_TITLE_SELECTOR = "[data-f0-chat-header-title]";
+
 export declare const F0ActionBar: WithDataTestIdReturnType_2<ForwardRefExoticComponent<F0ActionBarProps & RefAttributes<F0ActionBarRef>>>;
 
 declare interface F0ActionBarProps {
@@ -7969,7 +8000,7 @@ export declare interface F0CarouselDialogProps extends Pick<F0DialogInternalProp
  * the {@link F0ChatRuntime} from a surrounding `F0ChatProvider`. Panel controls
  * (fullscreen / close) are wired by the host so F0Chat stays transport-agnostic.
  */
-export declare const F0Chat: (props: F0ChatProps) => ReactNode;
+export declare const F0Chat: ({ surface, ...props }: F0ChatProps) => ReactNode;
 
 /** Attachment family, as the transcript classifies it (see
  * `utils/attachments.ts`). Note `video` is not an {@link F0ChatAttachment}
@@ -8088,6 +8119,12 @@ export declare type F0ChatCapabilities = {
     canViewInfo?: boolean;
     canEditMessage?: (message: F0ChatMessage) => boolean;
     canDeleteMessage?: (message: F0ChatMessage) => boolean;
+    /**
+     * Whether this message may be translated. Allowed when omitted, as long as the
+     * host provides `translateMessage`. When it refuses, the row is hidden, or
+     * shown as an upsell if the host also provides `requestTranslationUpsell`.
+     */
+    canTranslateMessage?: (message: F0ChatMessage) => boolean;
 };
 
 /**
@@ -8469,6 +8506,97 @@ export declare type F0ChatHeaderAction = {
     placement?: "menu" | "inline";
     /** Restrict the action to given channel types. Omit for all of them. */
     channelTypes?: F0ChatChannelType[];
+    /**
+     * TURNS AN INLINE ACTION INTO A TOGGLE, because that is what it has become:
+     * something with an on and an off. Starting a huddle is a button until the
+     * call exists — from then on the same control means "you are in it", and a
+     * reader coming back to the conversation has to be able to see that without
+     * pressing anything.
+     *
+     * Set it and F0 renders a real toggle with its `aria-pressed`, bordered so
+     * the on state reads as a state rather than as a hover that stuck. Leave it
+     * undefined for an action that only ever fires, which is most of them —
+     * `false` is not the same thing as absent here.
+     *
+     * Ignored in the overflow menu: a menu item is a line of text you press, and
+     * it has nowhere to wear a state.
+     */
+    active?: boolean;
+    /** The glyph for the `active` half, when it differs. Omit to keep `icon` in
+     * both states. */
+    activeIcon?: IconType;
+    /**
+     * Marks the action as destructive, so it reads as one in the overflow menu.
+     * Leaving a channel or archiving a conversation is not the same kind of thing
+     * as muting it, and a menu that renders them identically says it is.
+     * Ignored for `inline` actions — the row of icon buttons has no such state.
+     */
+    critical?: boolean;
+};
+
+/**
+ * THE HOST'S STATEMENT THAT HISTORY IS BEING WITHHELD. The loaded window has
+ * reached a boundary behind which there IS older history the reader is not
+ * allowed to see — a plan that only includes the last N days, a retention
+ * policy, a legal hold.
+ *
+ * F0 neither computes nor enforces it: the host filters `messages` itself and
+ * sets this together with `hasMoreOlder: false`. It cannot be derived here —
+ * after the host has filtered, "the conversation started 10 days ago" and
+ * "there are three years behind this" look identical from inside the panel.
+ *
+ * ABSENT ⇒ the oldest loaded message is the true beginning, or simply not
+ * loaded yet. A conversation that genuinely started last week must never carry
+ * one: the notice would claim something was taken away when nothing was.
+ *
+ * It is drawn as an `F0Card` whose only control is an upsell button, and the
+ * host owns every part of it. The copy for the same reason
+ * {@link F0ChatChannel.readOnlyNotice} is host-owned: only the host knows which
+ * plan this is, and it is the one with the translations. And the button as the
+ * WHOLE {@link UpsellingButtonProps} surface rather than a bare `onClick`,
+ * because asking for a plan to change is a REQUEST with an outcome — the
+ * loading label, the success and error copy and the next steps its confirmation
+ * dialog shows are all part of what a host configures. An action that merely
+ * navigates sets `showConfirmation: false`.
+ */
+export declare type F0ChatHistoryLimit = {
+    /** Headline. Says what is missing, not what to buy. */
+    title: string;
+    /** One sentence of context — which window is included, what lies behind it. */
+    description?: string;
+    /** Mark shown beside the copy. */
+    icon?: IconType;
+    /** The upsell request, whole — see above. */
+    action: UpsellingButtonProps;
+};
+
+/**
+ * WHAT A CONVERSATION WITH A WITHHELD PAST SAYS FOR ITSELF — the card F0 puts
+ * at the top of such a transcript, exported because the host needs THE SAME ONE
+ * for the pop-up it floats over the conversation on arrival.
+ *
+ * Exported rather than left to each host to rebuild: two cards that must look
+ * identical and are written twice are two cards that drift. They differ in one
+ * thing only, and it is the one thing they should differ in — the floating copy
+ * can be dismissed, the one at the top of history cannot. A close button there
+ * would take the explanation away from a boundary the reader reaches again on
+ * the next scroll, and F0 has nowhere to remember that it was closed.
+ *
+ * Its only standing control is an `UpsellingButton`: the request it sends and
+ * everything its confirmation dialog says belong to the host — see
+ * {@link F0ChatHistoryLimit}.
+ */
+export declare const F0ChatHistoryLimitCard: ({ notice, dismissActions, }: {
+    notice: F0ChatHistoryLimit;
+    /** Rendered after the upsell, in the order given. Omit where there is no way
+     * out — see above. */
+    dismissActions?: F0ChatHistoryLimitDismissAction[];
+}) => ReactNode;
+
+/** A way out of the card, for hosts that render it somewhere dismissable. */
+export declare type F0ChatHistoryLimitDismissAction = {
+    label: string;
+    onClick: () => void;
 };
 
 export declare type F0ChatImageAttachment = {
@@ -8612,6 +8740,12 @@ export declare type F0ChatMessage = {
      * reactions/read updates), so it never false-positives the label.
      */
     editedAt?: string;
+    /**
+     * Shown under `body`, which always stays the sent text, so copy, reply and
+     * edit keep using the original. Clear it when the text is edited: it
+     * translates the old text.
+     */
+    translation?: F0ChatMessageTranslation;
     /**
      * The message was drafted with One (Factorial's AI) and approved by its
      * author, who remains the sender. Drives the muted "by One" label
@@ -8644,6 +8778,16 @@ export declare type F0ChatMessageReply = {
  */
 export declare type F0ChatMessageStatus = "sending" | "sent" | "delivered" | "read" | "failed";
 
+/**
+ * Only the message text is translated, not attachments or link previews.
+ * `sourceLanguage` is the detected language of the original, as a BCP-47 code;
+ * without it the label reads "Translated".
+ */
+export declare type F0ChatMessageTranslation = {
+    body: string;
+    sourceLanguage?: string;
+};
+
 /**
  * A pinned post as the bar needs it: enough to name it, and its id to jump to.
  * The post itself is fetched by the jump, not carried here.
@@ -8852,11 +8996,22 @@ export declare type F0ChatPostRequiredAction = {
 };
 
 export declare type F0ChatProps = {
-    /** Whether the hosting panel is in fullscreen (controls the header toggle icon). */
+    /**
+     * Where the chat is mounted — see {@link F0ChatSurface}. On `"page"` the
+     * panel controls below are ignored, not merely unused: a conversation that is
+     * the page has nothing to close and nowhere to expand to, and leaving that to
+     * the convention of "don't pass the callback" is how it comes back.
+     * @default "panel"
+     */
+    surface?: F0ChatSurface;
+    /** Whether the hosting panel is in fullscreen (controls the header toggle
+     * icon). Ignored on the `page` surface. */
     isFullscreen?: boolean;
-    /** Toggle the hosting panel's fullscreen. Hidden when omitted. */
+    /** Toggle the hosting panel's fullscreen. Hidden when omitted, and always on
+     * the `page` surface. */
     onToggleFullscreen?: () => void;
-    /** Close the hosting panel. Hidden when omitted. */
+    /** Close the hosting panel. Hidden when omitted, and always on the `page`
+     * surface. */
     onClose?: () => void;
     /**
      * Host-provided header actions (pin, mute, edit group…). Search is the only
@@ -8874,6 +9029,43 @@ export declare type F0ChatProps = {
      * Undefined keeps the default header, so no existing usage changes.
      */
     header?: ReactNode | null;
+    /**
+     * Host chrome pinned to the END of the built-in header's action row, after
+     * the overflow menu and any inline actions.
+     *
+     * Not an `F0ChatHeaderAction`: those are things you do TO the conversation,
+     * and they are labels and icons F0 lays out. This is a rendered control that
+     * belongs to the app around the chat — the One switch on a full-page
+     * conversation, where there is no page header left to carry it.
+     *
+     * Ignored when `header` replaces the built-in one; that host already owns
+     * the whole row.
+     */
+    headerContent?: ReactNode;
+    /**
+     * THE HOST'S POP-UP OVER THE TOP OF THE CONVERSATION — full width, floating.
+     *
+     * Where a host says something ABOUT the conversation rather than in it:
+     * "older messages aren't included in your plan", "this channel is archived on
+     * Friday". It sits under the header and over the transcript, the width of the
+     * panel, and it is the shape a warning like that wants: a popover anchored to
+     * something in the header would be a fixed-width panel with an arrow pointing
+     * at a title that has nothing to do with what it says.
+     *
+     * IT FLOATS, and that is the point. Taking layout space would push the whole
+     * transcript down on arrival and pull it back up on dismissal — the reader's
+     * place in the conversation moving twice for a message they are about to
+     * close. Floating also means the virtualizer never measures around it, and
+     * the sticky date pill steps below it on its own
+     * (`CHAT_NOTICE_HEIGHT_PROPERTY`).
+     *
+     * It survives scrolling: this is a standing fact about the conversation, not
+     * something tied to where the reader is in it. Dismissing is the host's — F0
+     * renders what it is handed and remembers nothing, because when it shows and
+     * whether a dismissal outlives the session both depend on things F0 cannot
+     * see.
+     */
+    notice?: ReactNode;
 };
 
 /**
@@ -8919,6 +9111,17 @@ export declare type F0ChatRuntime = {
     typingUsers: F0ChatUser[];
     hasMoreOlder: boolean;
     loadingOlder: boolean;
+    /**
+     * Set ONLY once the window has reached a boundary the plan (or a retention
+     * rule) puts on history — see {@link F0ChatHistoryLimit}. F0 renders it at
+     * the very top of the transcript, and only in the settled state
+     * (`!hasMoreOlder && !loadingOlder`), so it can never appear above rows that
+     * are still being paginated in.
+     *
+     * It is the host's job to also report `hasMoreOlder: false` here: left true,
+     * the transcript would keep asking for pages it is never going to get.
+     */
+    historyLimit?: F0ChatHistoryLimit;
     /**
      * Whether there are newer messages than the loaded window — true after jumping
      * to an old message (e.g. a search hit), so the transcript isn't anchored to
@@ -8991,6 +9194,18 @@ export declare type F0ChatRuntime = {
      * `client.partialUpdateMessage`.
      */
     editMessage?: (id: string, input: F0ChatEditInput) => void | Promise<void>;
+    /**
+     * Omit to disable translation. The host answers by setting `translation` on
+     * the message; F0 stores no translated text.
+     */
+    translateMessage?: (id: string) => void | Promise<void>;
+    /** Omit and a translation stays visible once shown. */
+    hideMessageTranslation?: (id: string) => void;
+    /**
+     * When `canTranslateMessage` refuses, the Translate row still shows with an
+     * Upgrade tag and calls this instead.
+     */
+    requestTranslationUpsell?: () => void;
     /**
      * How long after sending a message stays editable (ms). The "Edit" action is
      * hidden once a message is older than this. Omit for no limit (editable
@@ -9258,6 +9473,20 @@ export declare type F0ChatShelfAction = {
  */
 export declare type F0ChatStatus = "connecting" | "ready" | "reconnecting" | "offline" | "error";
 
+/**
+ * Where the chat lives, which is the one thing it cannot work out for itself.
+ *
+ * `"panel"` (default) is a card inside the side panel: it can be closed and
+ * expanded, and the panel draws the border around it.
+ *
+ * `"page"` is the main content of a route — the conversation IS the page, so
+ * there is nothing to close and nowhere to expand to. `onClose`,
+ * `onToggleFullscreen` and `isFullscreen` are ignored rather than merely
+ * unused, the side panel is never consulted, and the header draws its own seam
+ * against the transcript in place of the card border it no longer has.
+ */
+export declare type F0ChatSurface = "panel" | "page";
+
 /**
  * Membership / lifecycle events rendered as a centered system row. Closed
  * union — the host maps unknown transport event kinds to a body-only system
@@ -10926,8 +11155,10 @@ export declare type F0MeetingRuntime = {
     localParticipantId: string;
     /**
      * Everyone in the room INCLUDING the local participant, in a stable order the
-     * host controls (join order). F0 owns speaker promotion and pagination on top
-     * of this — a host that reorders on every speaker change makes the grid churn.
+     * host controls (join order). F0 owns speaker promotion, pagination and the
+     * local participant's own position on top of this — your camera is always the
+     * last tile, whatever index you are at here. A host that reorders on every
+     * speaker change makes the grid churn.
      */
     participants: F0MeetingParticipant[];
     localMedia: F0MeetingLocalMedia;
@@ -10992,6 +11223,16 @@ export declare type F0MeetingSidePanelTab = {
 export declare type F0MeetingSignal = {
     /** 0..1, smoothed by the host. LiveKit `Participant.audioLevel`. */
     audioLevel: number;
+    /**
+     * Energy per frequency band, 0..1 each, low to high — LiveKit's
+     * `useMultibandTrackVolume`, or an `AnalyserNode` the host already has.
+     *
+     * Optional, and the waveform is honest about it: with a single `audioLevel`
+     * five bars can only be one number drawn five times, so they rise and fall
+     * together. Give it bands and each bar moves on its own, because each one is
+     * actually a different measurement.
+     */
+    bands?: readonly number[];
     isSpeaking: boolean;
     quality: F0MeetingConnectionQuality;
 };
@@ -14452,7 +14693,7 @@ declare type MeetingRoomChatProps = {
 };
 
 /**
- * The in-call panel: chat, transcript and notes beside the grid.
+ * The in-call panel: chat, transcript and notes, beside the grid in fullscreen.
  *
  * F0 owns the bar, the selection and the close button because the control that
  * opens the panel lives in F0's own action bar and needs the tab labels and
@@ -14462,15 +14703,23 @@ declare type MeetingRoomChatProps = {
  * particular: its transcript is virtualized, and measuring rows inside a
  * display:none subtree yields zero heights that the list then has to correct
  * on reveal.
+ *
+ * The width comes from `plan`, never from a class. It used to be a literal
+ * `w-[420px]` paired with a `SIDE_PANEL_WIDTH` nothing read — Tailwind cannot
+ * take a number, the two had to agree, and nothing checked that they did.
  */
-export declare const MeetingSidePanel: ({ panel }: MeetingSidePanelProps) => JSX_2.Element | null;
+export declare const MeetingSidePanel: ({ panel, plan }: MeetingSidePanelProps) => JSX_2.Element | null;
 
 declare type MeetingSidePanelProps = {
     panel: F0MeetingSidePanel;
+    /** Where it sits and how wide, decided by `planSidePanel` from the room. */
+    plan: SidePanelPlan;
 };
 
 export declare type MeetingSignalStore = F0MeetingSignalStore & {
     setAudioLevel: (participantId: string, level: number) => void;
+    /** Per-band energy for the waveform. See `F0MeetingSignal.bands`. */
+    setAudioBands: (participantId: string, bands: readonly number[]) => void;
     setSpeaking: (participantIds: readonly string[]) => void;
     setQuality: (participantId: string, quality: F0MeetingConnectionQuality) => void;
     remove: (participantId: string) => void;
@@ -14492,9 +14741,11 @@ declare type MeetingSurfaceContextValue = {
     /** What the user chose. Never mutated by the environment. */
     mode: F0MeetingSurfaceDestination;
     /**
-     * What actually renders. A small viewport or an unmounted inline slot derives
-     * a different mode without destroying the user's preference; so does an open
-     * picture-in-picture window, which is `pip` for as long as it is open.
+     * What actually renders. It differs from `mode` for exactly two reasons, and
+     * neither is the size of the screen: a place that is not there (an inline
+     * slot nobody registered, a panel no frame provides) derives to `floating`,
+     * and an open picture-in-picture window is `pip` for as long as it is open.
+     * The user's pick is never overwritten, only stood aside from.
      */
     effectiveMode: F0MeetingSurfaceMode;
     setMode: (mode: F0MeetingSurfaceDestination) => void;
@@ -14506,15 +14757,6 @@ declare type MeetingSurfaceContextValue = {
     settleRect: (rect: F0Rect) => void;
     /** Commit a resize, keeping the current anchor. */
     resizeRect: (rect: F0Rect) => void;
-    /** True below the md breakpoint: no dragging, pill instead of window. */
-    isCompactViewport: boolean;
-    /**
-     * The frame's content area. `panel` mode does NOT use it — there the room is
-     * the side panel's content and the panel places itself. It is what a window
-     * sizes itself against when it has to sit BESIDE the panel (see
-     * `fitToContent`), and the viewport when no frame published one.
-     */
-    panelArea: F0Rect;
     /**
      * Whether there is a side panel for the call to be the content of.
      *
@@ -14524,15 +14766,16 @@ declare type MeetingSurfaceContextValue = {
      * `floating` and the switch stops offering it.
      */
     hasPanelSlot: boolean;
-    setPanelSlot: (available: boolean) => void;
-    /** Registered by `F0MeetingSlot` so `inline` knows where to fly to. */
-    setInlineRect: (rect: F0Rect | null) => void;
     /**
-     * The application frame's content region, published by the frame itself. The
-     * side panel lives inside it — between the navigation and the content —
-     * rather than on top of the whole viewport.
+     * WHICH EDGE the slot is on, or `null` when there is none. The mode switch
+     * draws the panel with the side it actually docks to, so the control shows
+     * where the call is going rather than a generic panel that could be either.
      */
-    setFrameRect: (rect: F0Rect | null) => void;
+    panelSide: "left" | "right" | null;
+    /** `null` retires the slot; a side registers one. */
+    setPanelSlot: (side: "left" | "right" | null) => void;
+    /** Registered by `F0MeetingSlot` so `inline` knows where to fly to. */
+    setInlineRect: (rect: F0Rect | null) => void;
     /** What the user asked the spotlight to do, if anything. */
     focusIntent: F0MeetingFocusIntent;
     setFocusIntent: (intent: F0MeetingFocusIntent) => void;
@@ -14541,6 +14784,18 @@ declare type MeetingSurfaceContextValue = {
     setSidePanelOpen: (open: boolean) => void;
     activeTabId: string | null;
     setActiveTabId: (id: string) => void;
+    /**
+     * The width the panel was last dragged to — a PREFERENCE, not the width it
+     * draws at. `planSidePanel` clamps it against the room on every render and
+     * the clamp is never written back, so shrinking the window does not destroy
+     * a deliberate choice: widen it again and the panel returns to where it was.
+     *
+     * Not keyed by `roomId`, unlike the mode: how wide you like your chat is a
+     * fact about you, not about this call.
+     */
+    sidePanelWidth: number;
+    setSidePanelWidth: (width: number) => void;
+    resetSidePanelWidth: () => void;
     announce: (message: string) => void;
     liveMessage: string;
     /** What the browser offers for picture-in-picture, after the host's opt-out. */
@@ -17019,6 +17274,24 @@ export declare type SidebarChat = {
      * chat resolves, flip this to false and pass the real `label`/`avatar`.
      */
     loading?: boolean;
+    /**
+     * Where the conversation lives. With it the row is a real link, rendered
+     * through the host's router (`LinkProvider`), so cmd/middle-click, "open in
+     * new tab" and Back all work, and the active row is resolved from the URL
+     * rather than from `activeChatId`. Without it the row stays a button and
+     * `onClick` is the only way in.
+     *
+     * The host must mount `LinkProvider` with a live `currentPath` for the
+     * selection to follow the URL; if it does not, the row falls back to
+     * `activeChatId` rather than going dead.
+     */
+    href?: string;
+    /**
+     * Match `href` exactly when resolving the active state. Leave it off for a
+     * conversation with sub-routes (a thread, say) so the parent row stays lit.
+     * @default false
+     */
+    exactMatch?: boolean;
     onClick?: () => void;
     /** When > 0, the chat is rendered as unread (darker, bolder name). */
     unreadCount?: number;
@@ -17199,6 +17472,18 @@ export declare type SidebarChatProviderProps = {
 export declare type SidebarChatStatus = {
     icon: IconType;
     label: string;
+    /**
+     * THE STATUS IS LIVE, so the whole row wears it: the glyph takes the selected
+     * colour and the row takes the selected background — the same one the control
+     * that started it wears in the conversation's own header. A call in progress
+     * is the case this exists for, and it has to be findable from the list
+     * without opening anything.
+     *
+     * At most one status per row should carry it. An accent that several things
+     * share stops pointing at any of them, which is the whole job here: the row
+     * is coloured because ONE thing about it is happening right now.
+     */
+    accent?: boolean;
 };
 
 /**
@@ -17209,9 +17494,13 @@ export declare type SidebarChatStatus = {
 export declare type SidebarChatStore = {
     groups: SidebarChatGroup[];
     /**
-     * Id of the currently active chat. Chats are not navigation links — you can
-     * be on any page (e.g. the dashboard) with a chat active — so the active
-     * state is driven from here, not from the router.
+     * Id of the currently active chat, for rows with no `href`: you can be on any
+     * page (e.g. the dashboard) with such a chat active, so its active state is
+     * driven from here rather than from the router.
+     *
+     * A ROUTED row (one carrying `href`) takes its active state from the URL
+     * instead. This stays the source for unrouted rows, and the fallback for
+     * routed ones when no `LinkProvider` is mounted.
      */
     activeChatId?: string;
     /** Number of conversations with unread messages (across all groups). */
@@ -17386,6 +17675,18 @@ export declare type SidebarTab = {
      * tab (transparent background; the icon darkens on hover).
      */
     variant?: "default" | "ai";
+    /**
+     * Where this tab lives. With it the tab is a real link: cmd-click opens the
+     * section in a new tab, and switching sections is a navigation rather than a
+     * state change the host has to translate into one. The selection stays
+     * controlled — `activeTab` is still the host's, derived from its own route.
+     *
+     * Declaring `href` on ANY tab also turns off the mount-time restore of
+     * `persistKey` — see {@link usePersistedTab}.
+     */
+    href?: string;
+    /** Match `href` exactly when resolving the active state. @default false */
+    exactMatch?: boolean;
 };
 
 /**
@@ -17591,6 +17892,29 @@ declare type SidePanelContextValue = {
  */
 export declare type SidePanelLayout = "sidepanel" | "fullscreen";
 
+/**
+ * Where the in-call panel sits, which is a question about the ROOM'S width and
+ * never about the viewport's — the same rule the grid, the density table and
+ * the control bar already follow.
+ *
+ * - `beside`  the panel is a column in the row and the grid shrinks for it.
+ * - `over`    the panel floats on the grid's right edge; the grid keeps its
+ *             full width and never re-solves.
+ * - `full`    the panel takes the whole video area. The control bar is outside
+ *             the row, so leaving and muting are still there.
+ */
+declare type SidePanelLayout_2 = "beside" | "over" | "full";
+
+declare type SidePanelPlan = {
+    layout: SidePanelLayout_2;
+    /** The width to draw, already clamped. `full` reports the room's own. */
+    width: number;
+    min: number;
+    max: number;
+    /** A handle that cannot travel is worse than no handle. */
+    canResize: boolean;
+};
+
 /**
  * A product's claim on the panel.
  *
@@ -17612,6 +17936,20 @@ export declare type SidePanelViewDefinition = {
     available?: boolean;
     /** Edge this view docks to. Falls back to the panel's `side`. */
     side?: "left" | "right";
+    /**
+     * Can this view re-mount content persisted from a previous session? Only a
+     * view whose host actually answers `restoringViewId` — by calling `present`
+     * or `cancelRestore` — should say true.
+     *
+     * Default `false`, and deliberately so. With no restorer the panel holds a
+     * skeleton for the full safety timeout on every reload, including — after a
+     * product moves its content OUT of the panel — for an id nothing will ever
+     * claim again. The safe default is that the panel does not hold itself
+     * hostage for a host that never opted in; the host who wants the restore is
+     * also the host in a position to notice this field.
+     * @default false
+     */
+    restoresContent?: boolean;
 };
 
 /**
@@ -18757,6 +19095,54 @@ export declare type UpsellActionDefinition = {
 /** Returns the upsell action, or undefined to hide it. */
 export declare type UpsellActionDefinitionFn = () => UpsellActionDefinition | undefined;
 
+declare interface UpsellingButtonProps extends Omit<F0ButtonProps, "icon"> {
+    variant?: "promote" | "outlinePromote";
+    /**
+     * The text to be displayed in the button
+     */
+    label: string;
+    /**
+     * Whether to show the Upsell icon. Defaults to true.
+     */
+    showIcon?: boolean;
+    /**
+     * Function to be executed when the button is clicked
+     */
+    onRequest?: () => Promise<void> | void;
+    /**
+     * Whether to show the confirmation dialog after the request
+     */
+    showConfirmation?: boolean;
+    /**
+     * The error message to be displayed in the confirmation dialog
+     */
+    errorMessage: ErrorMessageProps;
+    /**
+     * The success message to be displayed in the confirmation dialog
+     */
+    successMessage: SuccessMessageProps;
+    /**
+     * The label to be displayed in the button when the request is being processed
+     */
+    loadingState: LoadingStateProps;
+    /**
+     * The next steps to be displayed in the confirmation dialog
+     */
+    nextSteps: NextStepsProps;
+    /**
+     * The label to be displayed in the close button of the confirmation dialog
+     */
+    closeLabel: string;
+    /**
+     * Callback to notify when the modal state changes (open/closed)
+     */
+    onModalStateChange?: (isOpen: boolean) => void;
+    /**
+     * Portal container for the confirmation dialog
+     */
+    portalContainer?: HTMLElement | null;
+}
+
 export declare function useAiPromotionChat(): AiPromotionChatProviderReturnValue;
 
 /**
@@ -20117,9 +20503,9 @@ declare namespace Calendar {
 
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
-        aiBlock: {
-            insertAIBlock: (data: AIBlockData, config: AIBlockConfig) => ReturnType;
-            executeAIAction: (actionType: string, config: AIBlockConfig) => ReturnType;
+        fontSize: {
+            setFontSize: (fontSize: string) => ReturnType;
+            unsetFontSize: () => ReturnType;
         };
     }
 }
@@ -20127,9 +20513,9 @@ declare module "@tiptap/core" {
 
 declare module "@tiptap/core" {
     interface Commands<ReturnType> {
-        fontSize: {
-            setFontSize: (fontSize: string) => ReturnType;
-            unsetFontSize: () => ReturnType;
+        aiBlock: {
+            insertAIBlock: (data: AIBlockData, config: AIBlockConfig) => ReturnType;
+            executeAIAction: (actionType: string, config: AIBlockConfig) => ReturnType;
         };
     }
 }