tempest-react-sdk 0.63.0 → 0.65.0

package/dist/tempest-react-sdk.d.ts

@@ -597,6 +597,33 @@ export declare interface ApiClient {
     put<T>(path: string, options?: RequestOptions): Promise<T>;
     patch<T>(path: string, options?: RequestOptions): Promise<T>;
     delete<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * Download a binary body through the full client pipeline.
+     *
+     * Same base URL, `getToken` header, 401 refresh-and-replay, `onUnauthorized`,
+     * logging, timeout and retry policy as {@link ApiClient.request} — only the
+     * decoding differs. Without it every download left the client: a hand-rolled
+     * `fetch` that re-declares the `Authorization` header and re-implements the
+     * error handling, and that has no refresh, which is the client's reason to
+     * exist.
+     *
+     * @param path - Path joined onto the client's base URL.
+     * @param options - The same options `request` takes; `method` defaults to GET.
+     * @returns The response body as a `Blob`.
+     * @throws TempestApiError On any non-2xx response, carrying the status.
+     */
+    blob(path: string, options?: RequestOptions): Promise<Blob>;
+    /**
+     * Download a binary body as an `ArrayBuffer`, for the callers a `Blob` does
+     * not serve — a decoder, a hash, a typed array fed to WebGL or to
+     * `onnxruntime-web`.
+     *
+     * @param path - Path joined onto the client's base URL.
+     * @param options - The same options `request` takes; `method` defaults to GET.
+     * @returns The response body as an `ArrayBuffer`.
+     * @throws TempestApiError On any non-2xx response, carrying the status.
+     */
+    arrayBuffer(path: string, options?: RequestOptions): Promise<ArrayBuffer>;
     upload<T>(path: string, formData: FormData, method?: "POST" | "PUT" | "PATCH", options?: Omit<RequestOptions, "body" | "method">): Promise<T>;
 }
 
@@ -2362,7 +2389,67 @@ export declare type ChartColorToken = string;
  *     onRetry={(message) => resend(message.id)}
  * />
  */
-export declare function Chat({ messages, currentUserId, onSend, onRetry, typing, renderAvatar, header, emptyState, groupWindowMs, locale, now, placeholder, composerActions, composerDisabled, onSendError, className, ...rest }: ChatProps): JSX.Element;
+export declare function Chat({ messages, currentUserId, onSend, onRetry, typing, renderAvatar, header, emptyState, groupWindowMs, locale, now, placeholder, composerActions, composerDisabled, onSendError, onReact, messageActions, onQuoteClick, className, ...rest }: ChatProps): JSX.Element;
+
+/** One attachment on a message. */
+export declare interface ChatAttachment {
+    /** Decides how it renders: a picture, a player, a voice note, a download row. */
+    kind: ChatAttachmentKind;
+    /** Where the bytes are. A blob URL works for a message still uploading. */
+    url: string;
+    /** File name, shown for `"file"` and used as the download name. */
+    name?: string;
+    /** MIME type, when the app knows it. */
+    mimeType?: string;
+    /** Size in bytes, shown next to a file. */
+    sizeBytes?: number;
+    /** Duration in ms, for audio, voice and video. */
+    durationMs?: number;
+    /** Poster for a video, or a smaller copy of an image. */
+    thumbnailUrl?: string;
+    /**
+     * Normalised peaks, `0`–`1`, for a voice note.
+     *
+     * A voice note without one is a grey rectangle: the waveform is what tells
+     * somebody whether this is a word or a two-minute monologue.
+     */
+    waveform?: readonly number[];
+    /** Alternative text for an image. */
+    alt?: string;
+}
+
+/** What a bubble can carry besides text. */
+export declare type ChatAttachmentKind = "image" | "video" | "audio" | "voice" | "file";
+
+/**
+ * One message bubble.
+ *
+ * Everything a messenger needs on a single message lives here, because every one
+ * of these was a thing each app rebuilt on top of a text-only bubble: the reply
+ * stub, attachments, reactions, per-recipient ticks, the actions menu, and the
+ * tombstone of a deleted message.
+ *
+ * @param props - The message and its handlers.
+ * @returns The bubble, wrapped in a context menu when actions are given.
+ */
+export declare function ChatBubble({ message, own, locale, onRetry, onReact, messageActions, onQuoteClick, }: ChatBubbleProps): JSX.Element;
+
+export declare interface ChatBubbleProps {
+    /** The message this bubble renders. */
+    message: ChatMessage;
+    /** Whether it belongs to the current user — side, colour and ticks. */
+    own: boolean;
+    /** Locale for labels. */
+    locale: "pt-BR" | "en";
+    /** Retry handler for a `"failed"` message. */
+    onRetry?: (message: ChatMessage) => void;
+    /** Toggles a reaction. Receives the emoji that was pressed. */
+    onReact?: (message: ChatMessage, emoji: string) => void;
+    /** Per-message actions, opened by right click, long press or the ⋮ button. */
+    messageActions?: (message: ChatMessage) => ContextMenuItem[];
+    /** Called when the quote stub is activated — scroll to the quoted message. */
+    onQuoteClick?: (message: ChatMessage) => void;
+}
 
 /**
  * The message field of a thread: a textarea that grows with its content, sends on
@@ -2422,8 +2509,14 @@ export declare interface ChatDay {
 export declare interface ChatMessage {
     /** Stable identity. Used as the React key and by `onRetry`. */
     id: string;
-    /** What was said. A node, so an app can render a link, an image or a quote. */
-    body: ReactNode;
+    /**
+     * What was said. A node, so an app can render a link, an image or a quote.
+     *
+     * Optional, because a message can be all attachment, or be a tombstone: a
+     * deleted message has no body to show, and requiring one made every app
+     * invent a placeholder string for the state the component now owns.
+     */
+    body?: ReactNode;
     /** Who said it. Compared against `currentUserId` to decide sides. */
     authorId: string;
     /** Display name. Falls back to `authorId` in the header of a run. */
@@ -2438,6 +2531,28 @@ export declare interface ChatMessage {
      * sitting right there.
      */
     status?: "sending" | "sent" | "read" | "failed";
+    /**
+     * Per-recipient delivery. Takes precedence over `status` for the ticks.
+     *
+     * Use it in a group, where "delivered to all" and "read by all" are different
+     * states and `status` can only say one thing.
+     */
+    receipt?: ChatReceipt;
+    /** Media, voice notes and documents carried by this message. */
+    attachments?: readonly ChatAttachment[];
+    /** The message this one replies to. */
+    quote?: ChatQuote;
+    /** Emoji reactions, already tallied by the app. */
+    reactions?: readonly ChatReaction[];
+    /**
+     * The message was deleted — it renders as a tombstone.
+     *
+     * A state, not a `body` the app swaps for a string: as a state the quote of
+     * it can be blanked too, and every app stops writing its own wording.
+     */
+    deleted?: boolean;
+    /** The message was edited after it was sent. */
+    edited?: boolean;
     /** Anything the app wants to carry through to its own renderers. */
     data?: Record<string, unknown>;
 }
@@ -2473,8 +2588,80 @@ export declare interface ChatProps extends Omit<HTMLAttributes<HTMLDivElement>,
     composerDisabled?: boolean;
     /** Called when `onSend` rejects. The draft stays in the field either way. */
     onSendError?: (error: unknown) => void;
+    /**
+     * Toggles a reaction on a message. Enables the reaction chips.
+     *
+     * Called with the emoji that was pressed, including one the user already
+     * reacted with: reacting again clears it, rather than stacking a second copy.
+     * The app owns that rule — the component only reports the press.
+     */
+    onReact?: (message: ChatMessage, emoji: string) => void;
+    /**
+     * Per-message actions: reply, forward, star, edit, delete.
+     *
+     * Returns the items for one message, opened by right click, by long press on
+     * touch, and by a `⋮` button on the bubble. Buttons painted on every bubble
+     * turn a conversation into a toolbar, which is why this is a menu.
+     */
+    messageActions?: (message: ChatMessage) => ContextMenuItem[];
+    /** Called when a reply stub is activated — scroll to the quoted message. */
+    onQuoteClick?: (message: ChatMessage) => void;
+}
+
+/**
+ * The stub of the message being replied to, shown above the body.
+ *
+ * `revoked` is not decoration: deleting the quoted message has to blank the
+ * quoted text, or it leaks through everyone who replied to it.
+ */
+export declare interface ChatQuote {
+    /** Id of the quoted message, so the app can scroll to it. */
+    messageId: string;
+    /** Who wrote it. */
+    senderName?: string;
+    /** A short piece of what it said. The component never truncates for you. */
+    excerpt?: string;
+    /** What the quoted message was, when it was not text. */
+    kind?: "text" | ChatAttachmentKind;
+    /** The quoted message was deleted — the excerpt is not shown. */
+    revoked?: boolean;
 }
 
+/** One emoji on a message, with its tally. */
+export declare interface ChatReaction {
+    /** The emoji itself. */
+    emoji: string;
+    /** How many people reacted with it. */
+    count: number;
+    /** Whether the current user is one of them — the chip reads as pressed. */
+    reacted?: boolean;
+    /** Who reacted, for the chip's tooltip. */
+    names?: readonly string[];
+}
+
+/**
+ * Per-recipient delivery, which is what a group needs.
+ *
+ * `status` is a boolean for the sender: it cannot say "delivered to everyone"
+ * versus "read by everyone", and only the second one turns the ticks blue.
+ */
+export declare interface ChatReceipt {
+    /** How many recipients have received it. */
+    deliveredTo: number;
+    /** How many have read it. */
+    readBy: number;
+    /** How many recipients there are. */
+    totalRecipients: number;
+}
+
+/**
+ * What the ticks on an outgoing message say.
+ *
+ * `"read"` is the only one that turns them blue, and in a group that means
+ * **everyone** has read it — the distinction `status: "read"` cannot make.
+ */
+export declare type ChatReceiptState = "sending" | "sent" | "delivered" | "read" | "failed";
+
 /** A run of consecutive messages from one author, under one day. */
 export declare interface ChatRun {
     kind: "run";
@@ -2936,17 +3123,26 @@ export declare interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
 export declare type ContainerSize = "sm" | "md" | "lg" | "xl" | "full";
 
 /**
- * Right-click context menu.
+ * Context menu — right click, long press, or click.
  *
- * - Opens at the cursor position on `onContextMenu` (default browser menu suppressed).
- * - Rendered through a {@link Portal} so it escapes parent overflow/stacking contexts.
- * - Closes on outside click, Escape, or item selection.
- * - Arrow Up/Down move focus across selectable items; Enter activates the focused item.
+ * - Opens at the pointer on `contextmenu`, and on a long press from touch or pen,
+ *   which is the gesture those pointers have instead of a right click. `trigger`
+ *   adds or replaces the mouse gesture; the long press is independent of it.
+ * - Clamped inside the viewport after it mounts, so a menu opened near an edge
+ *   moves in rather than overflowing — measured before the clamp: a 180 px menu
+ *   opened at `x=235` in a 320 px window ran 95 px off screen, cutting the right
+ *   edge off every label.
+ * - Rendered through a {@link Portal} so it escapes parent overflow/stacking
+ *   contexts.
+ * - Closes on outside click, Escape, scroll, resize, or item selection.
+ * - Arrow Up/Down move focus across selectable items and wrap; Home/End jump to
+ *   the ends; Enter activates the focused item. The menu itself takes focus when
+ *   it opens, so a screen reader announces it instead of staying on the trigger.
  *
  * @param props - The context menu props.
  * @returns The trigger wrapper plus the portalled menu when open.
  */
-export declare function ContextMenu({ items, children, className }: ContextMenuProps): JSX.Element;
+export declare function ContextMenu({ items, children, className, trigger, longPressDelay, viewportMargin, }: ContextMenuProps): JSX.Element;
 
 export declare type ContextMenuItem = {
     label: ReactNode;
@@ -2964,8 +3160,33 @@ export declare interface ContextMenuProps {
     children: ReactNode;
     /** Extra class names forwarded to the menu element. */
     className?: string;
+    /**
+     * Which pointer gesture opens the menu. Default `"contextmenu"`.
+     *
+     * `"click"` is the `⋮` button case, where a right click is the wrong gesture
+     * on the desktop and impossible on touch. `"both"` keeps the right click and
+     * adds the left one.
+     */
+    trigger?: ContextMenuTrigger;
+    /**
+     * Hold, in ms, that opens the menu from a coarse pointer. Default `500`.
+     *
+     * Set `0` to turn the long press off. It is on by default because touch has
+     * no right click: measured in Chrome with touch emulation (Pixel 7 and
+     * iPhone 13 profiles), a 900 ms hold fires `pointerdown`, `touchstart`,
+     * `pointerup`, `touchend` and `click` — and no `contextmenu` at all. Every
+     * action behind this menu was unreachable on a phone.
+     */
+    longPressDelay?: number;
+    /**
+     * Gap, in px, kept between the menu and the edge of the viewport. Default `8`.
+     */
+    viewportMargin?: number;
 }
 
+/** How the menu is opened by a pointer. Touch always gets the long press. */
+declare type ContextMenuTrigger = "contextmenu" | "click" | "both";
+
 /** WCAG 2.x contrast ratio between two hex colors, from `1` to `21`. */
 export declare function contrastRatio(a: string, b: string): number;
 
@@ -3039,6 +3260,12 @@ export declare const CPFInput: ForwardRefExoticComponent<Omit<InputProps, "value
  * is the signal to clear the session. Without `refresh`, the first `401` calls
  * it directly.
  *
+ * **Binary bodies** have their own methods — `blob()` and `arrayBuffer()` — which
+ * run the same pipeline and skip the parse. `request()` no longer decodes an
+ * unknown `Content-Type` as text either: it returns a `Blob` and says so once in
+ * a development build, because reading `image/jpeg` as UTF-8 destroyed the bytes
+ * on the way in.
+ *
  * **Retries** are off unless you set `retry`. See {@link ApiClientConfig.retry}
  * for the built-in policy; it never replays a write.
  *
@@ -3059,7 +3286,8 @@ export declare const CPFInput: ForwardRefExoticComponent<Omit<InputProps, "value
  * });
  *
  * @param config - Base URL plus the optional auth, retry and fetch hooks.
- * @returns A client with `request`/`get`/`post`/`put`/`patch`/`delete`/`upload`.
+ * @returns A client with `request`/`get`/`post`/`put`/`patch`/`delete`/`blob`/
+ * `arrayBuffer`/`upload`.
  */
 export declare function createApiClient(config: ApiClientConfig): ApiClient;
 
@@ -3401,7 +3629,7 @@ export declare function createInMemoryFlags(options?: InMemoryFlagsOptions): Fea
  * const packed = createJsonStorage(compressedStorageCodec);
  *
  * @param codec - Encoder pair. Defaults to plain JSON.
- * @returns A store with `get` / `set` / `remove`.
+ * @returns A store with `get` / `set` / `getRaw` / `setRaw` / `remove`.
  *
  * @tempest-limits empty-catch — every method is best-effort by contract:
  * `localStorage` throws on quota exhaustion, in Safari private mode, and when a
@@ -4256,7 +4484,15 @@ export declare interface CreateThemeOptions {
     chart?: string[];
     /** Corner radius scale. A preset name, or explicit per-step values. */
     radius?: ThemeRadius | Partial<Record<"xs" | "sm" | "md" | "lg" | "xl" | "2xl", string>>;
-    /** Alpha of `--tempest-focus-ring-color`, derived from the brand color. Default `0.35`. */
+    /**
+     * Opacity of `--tempest-focus-ring-color`. Omit it — the default ring is opaque.
+     *
+     * A translucent ring has no contrast of its own; it has the contrast of
+     * whatever it composites over. Passing a value below `1` reintroduces the
+     * failure 0.61.0 fixed in the built-in tokens, and logs a warning in a
+     * development build. Kept because a translucent ring over a background you
+     * control is a legitimate choice.
+     */
     focusRingAlpha?: number;
     /** Selector the light tokens are written under. Default `":root"`. */
     selector?: string;
@@ -5188,6 +5424,23 @@ export declare const DEFAULT_PUSH_TO_TALK_KEY = "Space";
  */
 export declare const DEFAULT_VOICE_CHAIN: VoiceChainSettings;
 
+/**
+ * The default instruction for a browser that cannot be prompted.
+ *
+ * Written out rather than left to the app because every app wrote the same two
+ * sentences, and getting them wrong is invisible: an iOS user who is told to
+ * look for an "Install" menu never finds one, because Safari puts it behind the
+ * Share sheet.
+ *
+ * On an Android fork the copy also offers the `intent://` link the SDK already
+ * builds — reopening the page in Chrome is the only path that reaches a real
+ * install on a browser whose menu has no install entry at all.
+ *
+ * @param input - The resolved method and the optional Chrome intent.
+ * @returns The instruction, or `null` when the method needs none.
+ */
+export declare function defaultInstallHint({ method, openInChromeIntent }: InstallHintInput): ReactNode;
+
 /**
  * Identity helper that types a declarative route tree. Use it so editors give
  * autocomplete and type-checking on every node; the array is returned as-is.
@@ -6331,12 +6584,37 @@ export declare function formatDateTimeForInput(value: string | Date): string;
 export declare function formatDurationMs(value: number): string;
 
 /**
- * Format a fraction (0-1) as a percentage with one decimal.
+ * Format a fraction (0-1) as a percentage.
+ *
+ * A non-finite input renders as `"—"` rather than `"NaN%"` or `"∞%"`, which is
+ * what `Intl.NumberFormat` produces and what a division by zero upstream puts on
+ * the screen. It matches `formatDurationMs`, which already answers that way.
+ *
+ * @example
+ * ```typescript
+ * formatPercent(0.9874);                // "98,7%"
+ * formatPercent(0.9874, { decimals: 2 }); // "98,74%"
+ * formatPercent(0 / 0);                 // "—"
+ * ```
  *
  * @param value - Fraction between 0 and 1.
- * @returns Formatted percent string, e.g. "12,5%".
+ * @param options - Rendering options; `decimals` defaults to 1.
+ * @returns Formatted percent string, e.g. "12,5%", or `"—"` for a non-finite input.
  */
-export declare function formatPercent(value: number): string;
+export declare function formatPercent(value: number, options?: FormatPercentOptions): string;
+
+/** How {@link formatPercent} renders a fraction. */
+export declare interface FormatPercentOptions {
+    /**
+     * Decimal places to show, fixed (padded as well as truncated).
+     *
+     * Defaults to `1`, which is what the function always did. Two is the case
+     * that produced this option: a confidence of 98,74% and one of 98,7% are the
+     * same number on a summary card and two different readings on a detail
+     * screen, so the precision belongs to the call site.
+     */
+    decimals?: number;
+}
 
 /**
  * Apply the Brazilian phone mask `(XX) XXXXX-XXXX` or `(XX) XXXX-XXXX`.
@@ -7075,11 +7353,15 @@ export declare interface InstallBackgroundSyncOptions {
 }
 
 /**
- * Dismissible bottom banner that invites the user to install the PWA. Wired to
- * {@link useBeforeInstallPrompt}: it renders only when the browser captured an
- * install prompt and the app is not already running standalone — so on
- * platforms that never fire `beforeinstallprompt` (e.g. iOS Safari) it stays
- * hidden and you can surface manual instructions elsewhere.
+ * Dismissible bottom banner that invites the user to install the PWA, wired to
+ * {@link useInstallPrompt}.
+ *
+ * Where the browser fires `beforeinstallprompt`, the button installs. Where it
+ * does not — iOS Safari, and the Android Chromium forks that strip the API — the
+ * banner shows that platform's instruction instead of disappearing. It used to
+ * disappear: built on `useBeforeInstallPrompt`, it rendered `null` exactly where
+ * the user has no other way to find the install entry, which is why every app
+ * kept a local copy of this component just to add the two missing paths.
  *
  * @tempest-limits empty-catch — persisting the dismissal is a courtesy, not the
  * feature. When `localStorage` refuses the write (quota, private mode) the banner
@@ -7093,7 +7375,7 @@ export declare interface InstallBackgroundSyncOptions {
  *     storageKey="famacha:install-dismissed"
  * />
  */
-export declare function InstallBanner({ title, description, installLabel, dismissLabel, icon, storageKey, onResult, className, }: InstallBannerProps): JSX.Element | null;
+export declare function InstallBanner({ title, description, installLabel, hintLabel, dismissLabel, icon, storageKey, declineCooldownMs, renderHint, manualFallbackDelayMs, onResult, className, }: InstallBannerProps): JSX.Element | null;
 
 export declare interface InstallBannerProps {
     /** Headline. Default `"Instale o app"`. */
@@ -7111,29 +7393,95 @@ export declare interface InstallBannerProps {
      * make dismissal last only for the current session (component state).
      */
     storageKey?: string;
+    /**
+     * How long, in ms, a dismissal lasts before the banner may return.
+     *
+     * Omitted, a dismissal written to `storageKey` is permanent, which is what
+     * the component always did and what a stored `"1"` keeps meaning. With a
+     * cooldown the dismissal is stored as a timestamp instead, so the banner
+     * comes back after the window — the same shape `useInstallPrompt` uses for
+     * its own decline.
+     */
+    declineCooldownMs?: number;
+    /**
+     * Install button label used when the browser cannot be prompted and the
+     * banner shows the manual instruction. Default `"Como instalar"`.
+     */
+    hintLabel?: string;
+    /**
+     * Replaces the instruction shown for the `"ios"` and `"manual"` methods.
+     *
+     * The default copy is in PT-BR and names the real menu entries.
+     */
+    renderHint?: RenderInstallHint;
+    /**
+     * How long, in ms, to wait for `beforeinstallprompt` before falling back to
+     * the manual instruction. Forwarded to {@link useInstallPrompt}; defaults to
+     * 3000 there.
+     */
+    manualFallbackDelayMs?: number;
     /** Called with the user's choice after the install prompt resolves. */
     onResult?: (outcome: InstallOutcome) => void;
     className?: string;
 }
 
 /**
- * Button wired to the PWA install prompt ({@link useBeforeInstallPrompt}).
- * Renders nothing when the app can't be installed — no prompt captured yet,
- * already installed, or running standalone — so you can drop it anywhere
- * without guarding visibility yourself.
+ * Button wired to PWA installation, through {@link useInstallPrompt}.
+ *
+ * Where the browser fires `beforeinstallprompt`, the click installs. Where it
+ * does not — iOS Safari, and the Android Chromium forks (Mi Browser, UC, Opera
+ * Mini, Huawei) that strip the API — the click reveals the instruction for that
+ * platform instead of the button disappearing.
+ *
+ * That disappearance was the defect: the component was built on
+ * `useBeforeInstallPrompt`, so it rendered `null` exactly where the user needs
+ * the most help, and every app re-implemented the iOS and manual paths locally.
+ * Nothing renders only when there is genuinely nothing to offer — already
+ * installed, running standalone, or inside the decline cooldown.
  *
  * Inherits every {@link Button} prop (`variant`, `size`, `leftIcon`, …).
  *
  * @example
  * <InstallButton variant="primary" leftIcon={<Download />} />
+ *
+ * @example
+ * <InstallButton renderHint={({ method }) => (method === "ios" ? <IOSSteps /> : <MenuSteps />)} />
  */
-export declare function InstallButton({ label, onResult, ...props }: InstallButtonProps): JSX.Element | null;
+export declare function InstallButton({ label, hintLabel, onResult, renderHint, manualFallbackDelayMs, wrapperClassName, ...props }: InstallButtonProps): JSX.Element | null;
 
 export declare interface InstallButtonProps extends Omit<ButtonProps, "onClick" | "children"> {
     /** Button label. Default `"Instalar app"`. */
     label?: ReactNode;
+    /**
+     * Label used when the browser cannot be prompted and the button reveals the
+     * manual instruction instead. Default `"Como instalar"`.
+     */
+    hintLabel?: ReactNode;
     /** Called with the user's choice after the install prompt resolves. */
     onResult?: (outcome: InstallOutcome) => void;
+    /**
+     * Replaces the instruction shown for the `"ios"` and `"manual"` methods.
+     *
+     * The default copy is in PT-BR and names the real menu entries. Pass this to
+     * translate it, to shorten it, or to point at a screenshot of your own.
+     */
+    renderHint?: RenderInstallHint;
+    /**
+     * How long, in ms, to wait for `beforeinstallprompt` before falling back to
+     * the manual instruction. Forwarded to {@link useInstallPrompt}; defaults to
+     * 3000 there.
+     */
+    manualFallbackDelayMs?: number;
+    /** Class applied to the wrapper that holds the button and the instruction. */
+    wrapperClassName?: string;
+}
+
+/** What an install affordance needs to render the instruction for a method. */
+export declare interface InstallHintInput {
+    /** The strategy `useInstallPrompt` resolved. */
+    method: InstallMethod;
+    /** An `intent://` URL that re-opens the page in Chrome on Android, if any. */
+    openInChromeIntent: string | null;
 }
 
 /**
@@ -7546,6 +7894,10 @@ export declare interface JsonStorage {
     /**
      * Read and decode a key.
      *
+     * The value is decoded by the store's codec — JSON for {@link storage} —
+     * which is what makes a key written as a bare string unreadable here: it is
+     * not the shape this method writes. {@link JsonStorage.getRaw} reads those.
+     *
      * @typeParam T - The expected value shape.
      * @param key - Storage key.
      * @param fallback - Returned when the key is absent, unreadable, or corrupt.
@@ -7555,11 +7907,42 @@ export declare interface JsonStorage {
     /**
      * Encode and write a key.
      *
+     * The value is **encoded** — `set("theme", "dark")` stores `"dark"` with the
+     * quotes, not `dark`. That matters when an existing key is being adopted:
+     * whatever read it before will no longer recognise what this writes, and the
+     * old value will no longer parse here. {@link JsonStorage.setRaw} is the
+     * passthrough.
+     *
      * @typeParam T - The value being stored.
      * @param key - Storage key.
      * @param value - Any value the codec can represent.
      */
     set<T>(key: string, value: T): void;
+    /**
+     * Read a key exactly as `localStorage` holds it, with no decoding.
+     *
+     * The escape hatch {@link JsonStorage.get} cannot be: `get` runs the codec,
+     * so a key holding a bare `dark` — written by another library, by the app
+     * before it adopted this wrapper, or by the SDK's own `ThemeProvider` —
+     * fails to parse and comes back as the fallback. Reading that key is a
+     * different operation, not a variant of the same one.
+     *
+     * @param key - Storage key.
+     * @returns The stored string, or `null` when the key is absent or storage is
+     *   unavailable.
+     */
+    getRaw(key: string): string | null;
+    /**
+     * Write a string exactly as given, with no encoding.
+     *
+     * The counterpart of {@link JsonStorage.getRaw}, and what keeps adoption from
+     * being a silent migration: `set("theme", "dark")` stores `"dark"` **with the
+     * quotes**, which the app's previous reader no longer recognises.
+     *
+     * @param key - Storage key.
+     * @param value - The exact string to store.
+     */
+    setRaw(key: string, value: string): void;
     /**
      * Delete a key.
      *
@@ -11057,6 +11440,24 @@ export declare function readRoundTripMs(report: RTCStatsReport): number | null;
  */
 export declare function readThemeToken(name: string, element?: Element | null): string;
 
+/**
+ * The sentence a reader gets for a receipt, for the tooltip and the screen reader.
+ *
+ * Partial counts are spelled out rather than rounded to a state: "delivered to 3
+ * of 9" is the information the sender actually wants when the ticks are not blue
+ * yet, and it is the part a glyph cannot carry.
+ *
+ * @param receipt - Per-recipient counts.
+ * @param strings - Locale strings for the thread.
+ * @returns One sentence describing delivery and reading.
+ */
+export declare function receiptLabel(receipt: ChatReceipt, strings: {
+    deliveredAll: string;
+    deliveredSome: (delivered: number, total: number) => string;
+    readAll: string;
+    readSome: (read: number, total: number) => string;
+}): string;
+
 export { redirect }
 
 /** Recommended refetch intervals (milliseconds). */
@@ -11249,6 +11650,9 @@ export declare interface RelativeTimeProps extends HTMLAttributes<HTMLTimeElemen
  */
 export declare function removeById<T, V extends Partial<Record<keyof T, unknown>> = T>(idField?: keyof T): (current: T[] | undefined, item: V) => T[];
 
+/** Renders the instruction shown when the browser has no install prompt. */
+export declare type RenderInstallHint = (input: InstallHintInput) => ReactNode;
+
 export declare interface ReorderPayload {
     from: number;
     to: number;
@@ -11340,6 +11744,29 @@ export declare function resolveDegradation(quality: MeshQuality, effective: Mesh
 
 export declare type ResolvedTheme = "light" | "dark";
 
+/**
+ * Resolve the tick state of an outgoing message.
+ *
+ * A group needs three states where a single message has two: sent to the server,
+ * delivered to the recipients, read by the recipients. A boolean `status` collapses
+ * the middle one, so an app that has per-recipient counts either invents its own
+ * glyph or shows a message as read when one person out of nine opened it.
+ *
+ * The counts win when they are there, and the thresholds are deliberately "all":
+ * blue ticks in every messenger mean the whole room, and reporting "read" for a
+ * partial count is the failure that makes people distrust the indicator entirely.
+ * A `totalRecipients` of zero — a note to self, a thread whose membership the app
+ * does not track — falls back to `status`, because "read by all of nobody" is not
+ * a claim worth making.
+ *
+ * `"failed"` and `"sending"` come from `status` regardless: they are about this
+ * side of the wire, and no recipient count exists yet.
+ *
+ * @param message - The message being rendered.
+ * @returns The tick state, or `null` when there is nothing to show.
+ */
+export declare function resolveReceiptState(message: ChatMessage): ChatReceiptState | null;
+
 /**
  * Responsive value — either a single value applied at all breakpoints, or
  * an object with `mobile` / `tablet` / `desktop` overrides. Apps can mix
@@ -11920,26 +12347,63 @@ export declare interface SegmentedControlProps<TValue extends string = string> e
 }
 
 /**
- * Native `<select>` wrapper with label/helper/error slots. Either provide
- * `options` for a quick render, or pass `<option>` children directly.
+ * Native `<select>` wrapper. Either provide `options` for a quick render, or
+ * pass `<option>` children directly.
+ *
+ * Two variants:
+ *
+ * - `"field"` (default) — label, control, helper text and error slot, for a form.
+ * - `"chip"` — the control alone, sized to its content, for a settings row where
+ *   the icon and the label are already on the left and the control belongs on the
+ *   right. Rendering the full field there stacks two labelled fields inside one
+ *   list item, which is why every app ended up hand-rolling a native `<select>`
+ *   with `appearance: none` — and hand-rolling it loses the focus ring, the
+ *   disabled styling and the caret this component already solves.
+ *
+ * @example
+ * <Select label="Estado" options={states} placeholder="Selecione" />
+ *
+ * @example
+ * <ListTile title="Idioma" trailing={<Select variant="chip" aria-label="Idioma" options={langs} />} />
  */
 export declare const Select: ForwardRefExoticComponent<SelectProps & RefAttributes<HTMLSelectElement>>;
 
-export declare interface SelectOption {
-    value: string | number;
-    label: string;
-    disabled?: boolean;
+/** What both variants of {@link Select} accept. */
+declare interface SelectBaseProps extends SelectHTMLAttributes<HTMLSelectElement> {
+    options?: SelectOption[];
+    placeholder?: string;
+    wrapperClassName?: string;
 }
 
-export declare interface SelectProps extends SelectHTMLAttributes<HTMLSelectElement> {
+/**
+ * The bare control, sized to its content.
+ *
+ * `aria-label` is required rather than optional, because the variant removes the
+ * only visible label the component had. A settings row names the control in the
+ * row's own text, which the `<select>` has no relationship to — so without this
+ * the screen reader announces a combobox with no name at all.
+ */
+declare interface SelectChipProps extends SelectBaseProps {
+    variant: "chip";
+    "aria-label": string;
+}
+
+/** The full form field: label, control, helper text and error slot. */
+declare interface SelectFieldProps extends SelectBaseProps {
+    variant?: "field";
     label?: string;
     helperText?: string;
     error?: string;
-    options?: SelectOption[];
-    placeholder?: string;
-    wrapperClassName?: string;
 }
 
+export declare interface SelectOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+}
+
+export declare type SelectProps = SelectFieldProps | SelectChipProps;
+
 /**
  * Minimal subset of `@sentry/browser` used by the adapter. Lets you pass
  * either the real SDK module (`import * as Sentry from "@sentry/browser"`)
@@ -12855,6 +13319,11 @@ export declare function stopAudio(): void;
 /**
  * Typed wrapper around `localStorage` that JSON-encodes values and silently
  * handles environments where storage is unavailable (SSR, private mode).
+ *
+ * `get`/`set` encode; `getRaw`/`setRaw` do not. Reach for the raw pair when the
+ * key is shared with something that does not speak JSON — an existing key in an
+ * app adopting this wrapper, a key another library owns, or the theme
+ * preference the SDK's own `ThemeProvider` stores as a bare string.
  */
 export declare const storage: JsonStorage;
 
@@ -14986,6 +15455,12 @@ export declare function useIdle(timeout?: number): boolean;
  * mode, and applies a decline cooldown persisted in `localStorage`. The
  * resulting `method` tells the UI which install affordance to render.
  *
+ * Both sides of that persistence are best-effort: `localStorage` throws in
+ * Safari private mode and in a cross-origin frame with storage blocked, and an
+ * exception raised while resolving an install CTA would take the page down with
+ * it. A refused read means "no decline recorded"; a refused write means the CTA
+ * may come back next visit.
+ *
  * The decline persistence is pluggable through
  * {@link UseInstallPromptOptions.declineStorageKey} and
  * {@link UseInstallPromptOptions.declineCooldownMs} — no app-specific storage