@seekbuddy/dsh-ui 0.0.0-stage → 0.2.0-beta.0

package/dist/types/MenuSurface.d.ts

@@ -0,0 +1,15 @@
+/** Shared menu material and the macOS backing that lets Chromium blur transparent windows. */
+import { type ComponentPropsWithoutRef } from 'react';
+/** Menu containers preserve native div props and refs. */
+export interface MenuSurfaceProps extends ComponentPropsWithoutRef<'div'> {
+    /** Match the shared compact menu's smaller outer radius. */
+    compact?: boolean;
+}
+/**
+ * Paint a menu and, on macOS, an opaque backing behind the page content within its bounds.
+ * CSS anchors keep each backing aligned during placement, resizing, and nested-menu movement.
+ * @param props - Div content and placement, and compact geometry.
+ * @param ref - The visible menu div, excluding the non-interactive backing.
+ * @returns Menu content plus a backing portal removed with the menu.
+ */
+export declare const MenuSurface: import("react").ForwardRefExoticComponent<MenuSurfaceProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/Modal.d.ts

@@ -0,0 +1,43 @@
+import type { KeyboardEventHandler, ReactNode } from 'react';
+interface ModalBaseProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    description?: string;
+    children?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    shortcutModal?: string;
+    onKeyDownCapture?: KeyboardEventHandler<HTMLDivElement>;
+    backdropBlur?: boolean;
+}
+type ModalProps = ModalBaseProps & ({
+    headless: true;
+    closeLabel?: never;
+} | {
+    headless?: false;
+    closeLabel: string;
+});
+/**
+ * Render a centered, body-portaled modal over a blurred page mask.
+ * @param props.open - whether the dialog is showing.
+ * @param props.onClose - application close command, Escape, or mask click; while a menu is open inside the
+ * dialog, Escape belongs to that menu first.
+ * @param props.title - dialog heading (aria-label in every mode).
+ * @param props.closeLabel - localized accessible close-button label.
+ * @param props.description - optional supporting sentence under the title.
+ * @param props.children - dialog body; mark its initial-focus control with
+ * data-modal-autofocus instead of React autoFocus to preserve return focus.
+ * @param props.footer - action row (Cancel / Create).
+ * @param props.contentClassName - optional class for a scrollable content region.
+ * @param props.backdropBlur - disable when the caller already blurs the page; defaults to true.
+ * @param props.shortcutModal - command scope allowed by shortcut owners; unnamed
+ * dialogs block application commands unless their owner allows the "other" scope.
+ * @param props.headless - render children directly in the card (no default
+ * header/close/body chrome); mask, card, Escape, and aria-label remain.
+ * @param props.onKeyDownCapture - handle a nested dialog's keys before the document Escape listeners.
+ * @returns null when closed; otherwise the overlay tree.
+ */
+export declare function Modal({ open, onClose, title, closeLabel, description, children, footer, className, contentClassName, onKeyDownCapture, headless, backdropBlur, shortcutModal, }: ModalProps): import("react").ReactPortal | null;
+export {};

package/dist/types/PermissionIcon.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.js';
+/**
+ * Render the read-only permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconReadOnlyRegular(props: IconProps): ReactNode;
+/**
+ * Render the read-only permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconReadOnlyMedium(props: IconProps): ReactNode;
+/**
+ * Render the workspace-write permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconWorkspaceWriteRegular(props: IconProps): ReactNode;
+/**
+ * Render the workspace-write permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconWorkspaceWriteMedium(props: IconProps): ReactNode;
+/**
+ * Render the full-access permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconFullAccessRegular(props: IconProps): ReactNode;
+/**
+ * Render the full-access permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconFullAccessMedium(props: IconProps): ReactNode;

package/dist/types/Pill.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonHTMLAttributes, ReactNode } from 'react';
+/**
+ * Render a pill chip. Interactive when onClick is supplied (renders a button);
+ * otherwise a static span.
+ * @param props.active - selected/active visual state.
+ * @returns pill element.
+ */
+export declare function Pill({ active, className, children, onClick, ...rest }: {
+    active?: boolean;
+    className?: string | undefined;
+    children?: ReactNode;
+} & ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;

package/dist/types/ReadBlock.d.ts

@@ -0,0 +1,47 @@
+import { type CodeToolbarLabels } from './CodeToolbar.js';
+/**
+ * Content lines shown before the height cap collapses the middle. Matches
+ * TerminalBlock's default so a long read and a long command output cut at the
+ * same place in the same flow.
+ */
+export declare const DEFAULT_READ_MAX_LINES = 16;
+/** One line of the read window: its file line number and its text (no trailing newline). */
+export interface ReadBlockLine {
+    /** 1-based line number in the file (a window past an offset keeps the file's own numbering). */
+    number: number;
+    /** The line's text, already truncated to the read tool's per-line cap. */
+    text: string;
+}
+export interface ReadBlockProps {
+    /** Banner label (the file path, or a tool-supplied replacement title); omitted draws no label. */
+    label?: string | undefined;
+    /** The returned window's lines, in file order, each keeping its file line number. */
+    lines: readonly ReadBlockLine[];
+    /** Localized chrome supplied by the owning render site. */
+    labels: ReadBlockLabels;
+    /** Exact total line count in the file, for the "showing N of M" note when the read is a window. */
+    totalLines: number;
+    /** Grammar hint (a file-extension-derived language id); unknown or absent = plain monospace. */
+    lang?: string | undefined;
+    /** Height cap in content lines before the middle collapses (default {@link DEFAULT_READ_MAX_LINES}). */
+    maxLines?: number | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+}
+/** Localized chrome for {@link ReadBlock}. */
+export interface ReadBlockLabels extends CodeToolbarLabels {
+    window: (shown: number, total: number) => string;
+    copy: string;
+    copied: string;
+    collapseAria: string;
+    expandAria: (hidden: number) => string;
+    collapse: string;
+    expand: (hidden: number) => string;
+}
+/**
+ * Render a read tool result as a line-numbered, optionally syntax-highlighted
+ * file view.
+ * @param props - see {@link ReadBlockProps}.
+ * @returns the read block element.
+ */
+export declare function ReadBlock({ label, labels, lines, totalLines, lang, maxLines, className, }: ReadBlockProps): import("react").JSX.Element;

package/dist/types/ReferenceIcon.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.js';
+/** Reference domains with distinct composer and transcript glyphs. */
+export type ReferenceIconKind = 'session' | 'file' | 'folder';
+/** Props shared by inline reference glyphs. */
+export interface ReferenceIconProps extends IconProps {
+    kind: ReferenceIconKind;
+}
+/**
+ * Render a regular one-pixel reference icon.
+ * @param props - Reference kind, size, and optional class.
+ * @returns The regular decorative reference glyph.
+ */
+export declare function ReferenceIconRegular(props: ReferenceIconProps): ReactNode;
+/**
+ * Render a medium 1.3px reference icon.
+ * @param props - Reference kind, size, and optional class.
+ * @returns The medium decorative reference glyph.
+ */
+export declare function ReferenceIconMedium(props: ReferenceIconProps): ReactNode;

package/dist/types/RiskConfirmation.d.ts

@@ -0,0 +1,19 @@
+export interface RiskConfirmationProps {
+    open: boolean;
+    title: string;
+    description: string;
+    acknowledgeLabel: string;
+    cancelLabel: string;
+    closeLabel: string;
+    confirmLabel: string;
+    acknowledged: boolean;
+    disabled?: boolean;
+    onAcknowledgedChange: (acknowledged: boolean) => void;
+    onCancel: () => void;
+    onConfirm: () => void;
+}
+/**
+ * Render one in-page confirmation whose primary action is unavailable until
+ * the caller-controlled acknowledgement is checked.
+ */
+export declare function RiskConfirmation({ open, title, description, acknowledgeLabel, cancelLabel, closeLabel, confirmLabel, acknowledged, disabled, onAcknowledgedChange, onCancel, onConfirm, }: RiskConfirmationProps): import("react").JSX.Element;

package/dist/types/SearchBlock.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Result rows shown before the height cap collapses the middle. Matches
+ * {@link DEFAULT_TERMINAL_MAX_LINES} so a search card and a terminal card cut a
+ * long result at the same place.
+ */
+export declare const DEFAULT_SEARCH_MAX_LINES = 16;
+/** One matched line inside a {@link SearchFileGroup}: its 1-based line number and text. */
+export interface SearchBlockLineMatch {
+    /** 1-based line number of the match within its file. */
+    lineNumber: number;
+    /** The matched line text, as the tool surfaced it. */
+    line: string;
+}
+/** One file's grouped matches, in first-seen file order. */
+export interface SearchFileGroup {
+    /** The file the matches belong to (the display path). */
+    path: string;
+    /** The file's matched lines, in output order. */
+    matches: SearchBlockLineMatch[];
+}
+/** Fields both search shapes carry (the render site positions; this component draws). */
+interface SearchBlockCommon {
+    /** Localized chrome supplied by the owning render site. */
+    labels: SearchBlockLabels;
+    /**
+     * Whether the tool capped the inline result: the shape carries only the
+     * retained results, not every result the search found. The banner summary
+     * folds the pre-cap `total` in (`显示 X / 共 N …`) so the card never presents a
+     * capped result as complete.
+     */
+    truncated: boolean;
+    /** Total results the search found before capping (equals the retained count when not `truncated`). */
+    total: number;
+    /** Height cap in rows before the middle collapses (default {@link DEFAULT_SEARCH_MAX_LINES}). */
+    maxLines?: number | undefined;
+    /** Extra class merged onto the wrapper. */
+    className?: string | undefined;
+}
+/** Localized chrome for {@link SearchBlock}. */
+export interface SearchBlockLabels {
+    pathsSummary: (shown: number, total: number, truncated: boolean) => string;
+    matchesSummary: (shown: number, total: number, files: number, truncated: boolean) => string;
+    copy: string;
+    copied: string;
+    noResults: string;
+    collapseAria: string;
+    expandAria: (hidden: number) => string;
+    collapse: string;
+    expand: (hidden: number) => string;
+}
+/** Props for the grouped-matches (`grep`) shape. */
+export interface SearchMatchesBlockProps extends SearchBlockCommon {
+    kind: 'matches';
+    /** Matched lines grouped by file, in first-seen file order. */
+    files: SearchFileGroup[];
+}
+/** Props for the flat-path (`glob`) shape. */
+export interface SearchPathsBlockProps extends SearchBlockCommon {
+    kind: 'paths';
+    /** The discovered paths, in the tool's result order (the retained page when `truncated`). */
+    paths: string[];
+}
+/** {@link SearchBlock} props: one card, two `kind`-discriminated shapes. */
+export type SearchBlockProps = SearchMatchesBlockProps | SearchPathsBlockProps;
+/**
+ * Render a completed search as a grouped-matches or flat-path card.
+ * @param props - see {@link SearchBlockProps}.
+ * @returns the search block element.
+ */
+export declare function SearchBlock(props: SearchBlockProps): import("react").JSX.Element;
+export {};

package/dist/types/SegmentedControl.d.ts

@@ -0,0 +1,34 @@
+/** One segment of a {@link SegmentedControl}. */
+export interface SegmentedControlOption<Value extends string> {
+    /** The value the owner receives when this segment is chosen. */
+    value: Value;
+    /** Localized segment text. */
+    label: string;
+    /** Whether the segment refuses selection. */
+    disabled?: boolean;
+    /** Localized hover text, typically why the segment is locked. */
+    title?: string;
+}
+/**
+ * Render a segmented control.
+ * @param props.id - the owner's base id: each tab is `<id>-<value>` and names
+ * `<id>-<value>-panel` as the panel it controls.
+ * @param props.value - the selected option's value; the control is fully controlled.
+ * @param props.options - the segments in display order; at least two.
+ * @param props.onChange - called with the value a click or a walk key asks for,
+ * never with the value already selected.
+ * @param props.label - localized accessible name of the tablist.
+ * @param props.disabled - lock every segment, typically while the shown panel
+ * has a write or a fetch in flight that switching would orphan.
+ * @param props.className - extra class for layout placement.
+ * @returns the tablist element.
+ */
+export declare function SegmentedControl<Value extends string>({ id, value, options, onChange, label, disabled, className, }: {
+    id: string;
+    value: Value;
+    options: readonly SegmentedControlOption<Value>[];
+    onChange: (next: Value) => void;
+    label: string;
+    disabled?: boolean;
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/SegmentedTabs.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+/** A tab links its localized label to a caller-owned panel. */
+export interface SegmentedTab<Value extends string = string> {
+    value: Value;
+    label: ReactNode;
+    id: string;
+    panelId: string;
+}
+/**
+ * Render equal-width, controlled tabs with a sliding selection indicator.
+ * @param props.items - non-empty ordered tabs with unique values and DOM ids.
+ * @param props.value - selected value, which must belong to items.
+ * @param props.onChange - selection requested by click, Left/Right, or Home/End.
+ * Keyboard selection also moves focus; only the selected tab is a tab stop.
+ * @param props.label - localized accessible name for the tab list.
+ * @param props.className - layout placement; panels remain caller-owned.
+ * @returns the tab list, without its panels.
+ */
+export declare function SegmentedTabs<Value extends string>({ items, value, onChange, label, className, }: {
+    items: readonly [SegmentedTab<Value>, ...SegmentedTab<Value>[]];
+    value: Value;
+    onChange: (value: Value) => void;
+    label: string;
+    className?: string | undefined;
+}): ReactNode;

package/dist/types/ShortcutKeys.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Render one command's keycaps without owning binding defaults or localized copy.
+ * @param props - effective key labels, presentation variant and optional interaction styling.
+ * @returns unboxed keys by default, or tooltip keycaps with plus-separated combinations grouped together.
+ */
+export declare function ShortcutKeys({ keys, variant, className, }: {
+    keys: readonly string[];
+    variant?: 'plain' | 'tooltip';
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/SiteGlyph.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Site marks for well-known external link hosts. {@link LinkIconMedium} renders one in
+ * the leading glyph seat, so a familiar destination leads with its own mark
+ * instead of the generic globe. The marks are the `simple-icons` artwork set
+ * (CC0-1.0), pinned by this package's dependency on it; each mark takes the
+ * link's `currentColor` rather than the brand fill that set records.
+ */
+import type { ReactElement } from 'react';
+/** Props for {@link siteGlyph}: the destination plus the shared icon sizing seat. */
+interface SiteGlyphProps {
+    /** The link destination; only an absolute http(s) URL can name a host. */
+    href: string | undefined;
+    /** Square edge in px. */
+    size: number;
+    /** Extra class for layout placement. */
+    className?: string | undefined;
+}
+/**
+ * Render the site mark for a known external destination.
+ * @param props - The destination and the icon sizing seat.
+ * @returns The site's mark riding currentColor, or undefined for an unknown site.
+ */
+export declare function siteGlyph({ href, size, className }: SiteGlyphProps): ReactElement | undefined;
+export {};

package/dist/types/StateDot.d.ts

@@ -0,0 +1,19 @@
+/**
+ * State semantic: green done / amber user-attention / tertiary-grey loading /
+ * red error / neutral-grey idle for a tracked subject with nothing in progress.
+ */
+export type StateDotState = 'done' | 'warning' | 'ongoing' | 'error' | 'idle';
+/**
+ * Render a state dot.
+ * @param props.state - which of `done`, `warning`, `ongoing`, `error`, or `idle` to show.
+ * @param props.size - outer diameter in px; defaults to 14 for ongoing and 10 for solid states.
+ * @param props.className - extra class for layout placement.
+ * @param props.appearance - compact dot by default; step uses a filled check or hollow pending circle.
+ * @returns the dot element (aria-hidden; pair with text for accessibility).
+ */
+export declare function StateDot({ state, size, className, appearance, }: {
+    state: StateDotState;
+    size?: number | undefined;
+    className?: string | undefined;
+    appearance?: 'dot' | 'step';
+}): import("react").JSX.Element;

package/dist/types/Switch.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Render a toggle switch.
+ * @param props.checked - the current state; the control is fully controlled.
+ * @param props.onChange - called with the state the click asks for.
+ * @param props.label - localized accessible name, owned by the render site.
+ * @param props.disabled - whether the control refuses input; owners also set it
+ * while a write is in flight, not only when a deployment locks the toggle.
+ * @param props.title - localized hover text, typically why the toggle is locked.
+ * @param props.className - extra class for layout placement.
+ * @returns the switch element.
+ */
+export declare function Switch({ checked, onChange, label, disabled, title, className, }: {
+    checked: boolean;
+    onChange: (next: boolean) => void;
+    label: string;
+    disabled?: boolean;
+    title?: string | undefined;
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/types/Tag.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+/** Palette selector; each tone names one shipped appearance. */
+export type TagTone = 
+/** Hairline outline on tertiary text: the read-only default. */
+'outline'
+/** Inverted fill: one tag per group that names the current selection. */
+ | 'solid'
+/** Platform-gray fill: a neutral fact with no status meaning. */
+ | 'neutral'
+/** Text only, no fill: a fact stated more quietly than `neutral`. */
+ | 'quiet'
+/** Tinted green: a healthy or enabled state. */
+ | 'success'
+/** Tinted blue: informational classification, not health. */
+ | 'info'
+/** Tinted amber: attention needed, not yet a failure. */
+ | 'warning'
+/** Tinted red: a failure. */
+ | 'danger';
+/**
+ * Render a read-only tag.
+ * @param props.tone - which palette to use (default `outline`).
+ * @param props.className - extra class for layout placement.
+ * @param props.children - the localized label, owned by the render site.
+ * @returns the tag element.
+ */
+export declare function Tag({ tone, className, children, }: {
+    tone?: TagTone;
+    className?: string | undefined;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/TerminalBlock.d.ts

@@ -0,0 +1,77 @@
+/** Output lines shown before the height cap collapses the middle. */
+export declare const DEFAULT_TERMINAL_MAX_LINES = 16;
+/**
+ * Display copy for the terminal surface; the owner passes localized labels
+ * (this package is cordis-free, so copy arrives via props).
+ */
+export interface TerminalBlockLabels {
+    /** Status pill text for a signal-terminated command. */
+    signal: (signal: string) => string;
+    /** Status pill text for a non-zero exit code. */
+    exitCode: (exitCode: number) => string;
+    /** Status pill text for a command that ended without an exit code: killed by a signal the view does not know, or never started. */
+    noExitCode: string;
+    /** Run-state text while the command is still running. */
+    running: string;
+    /** Run-state text for a signal or non-zero-exit settle. */
+    failed: string;
+    /** Run-state text for a clean settle. */
+    done: string;
+    /** Copy-button idle label. */
+    copy: string;
+    /** Copy-button label during the post-copy confirmation window. */
+    copied: string;
+    /** Placeholder when a settled command produced no visible output. */
+    noOutput: string;
+    /** Collapse-toggle aria label while expanded. */
+    collapseAria: string;
+    /** Collapse-toggle text while expanded. */
+    collapse: string;
+    /** Expand-toggle aria label while capped, given the hidden line count. */
+    expandAria: (hidden: number) => string;
+    /** Expand-toggle text while capped, given the hidden line count. */
+    expand: (hidden: number) => string;
+}
+export interface TerminalBlockProps {
+    /** The command line, rendered verbatim after the prompt label. */
+    command: string;
+    /** Working directory for the prompt label; absent renders a plain `$`. */
+    cwd?: string | undefined;
+    /** Absolute home directory, so a cwd equal to it collapses to `~`; absent disables that collapse. */
+    home?: string | undefined;
+    /** The command's output text; may contain ANSI escape sequences. */
+    output?: string | undefined;
+    /** Settled exit code; a non-zero value renders the status pill, and null (settled without one) the no-exit-code pill. */
+    exitCode?: number | null | undefined;
+    /** Settled terminating signal name; any value renders the status pill, taking precedence over the exit code. */
+    signal?: string | undefined;
+    /**
+     * The command is still running: with no `output` the block shows the prompt
+     * line alone; with output it renders the live text under the running state.
+     */
+    running?: boolean | undefined;
+    /** Height cap in output lines before the middle collapses (default {@link DEFAULT_TERMINAL_MAX_LINES}); Infinity disables the cap. */
+    maxLines?: number | undefined;
+    /**
+     * Copy-control payload override; the control copies the raw output when
+     * absent. Supplying it also keeps the control rendered before any output
+     * exists — a command is copyable before it prints.
+     */
+    copyText?: string | undefined;
+    /**
+     * Draw the run-state dot and its assistive label in the card gutter
+     * (default true). Hosts whose surrounding row already carries the same
+     * state omit both and reclaim the gutter via `--dsl-terminal-gutter`.
+     */
+    runStateDot?: boolean | undefined;
+    /** Extra class merged onto the wrapper (callers position; this component draws). */
+    className?: string | undefined;
+    /** Localized display copy supplied by the owning render site. */
+    labels: TerminalBlockLabels;
+}
+/**
+ * Render a shell command as a terminal surface.
+ * @param props - see {@link TerminalBlockProps}.
+ * @returns the terminal block element.
+ */
+export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, maxLines, copyText, runStateDot, className, labels, }: TerminalBlockProps): import("react").JSX.Element;

package/dist/types/TextShimmer.d.ts

@@ -0,0 +1,22 @@
+/** Text activity animation shared by a row and its nested text fragments. */
+import * as React from 'react';
+import { type ReactNode } from 'react';
+/** Text and activity supplied by the owning row. */
+export interface TextShimmerProps {
+    /** Text or presentational children with text in nested TextShimmer instances. No effects or element ids. */
+    children: ReactNode;
+    /** Whether to animate; nested instances share the containing row's activity. */
+    active?: boolean | undefined;
+    className?: string | undefined;
+    /** Layout class applied equally to the base and decorative content. */
+    contentClassName?: string | undefined;
+}
+/**
+ * Render text with one shared highlight while retaining selectable, accessible content.
+ * Nested instances inherit the outer animation. Keep icons outside; mark decorative
+ * separators with data-shimmer-decoration so their background follows the highlight.
+ * Active children also render in an inert, clipped decoration; supply only presentation.
+ * @param props - localized text, running state, and owner styling.
+ * @returns retained text and its optional decorative highlight.
+ */
+export declare const TextShimmer: React.MemoExoticComponent<({ children, active, className, contentClassName, }: TextShimmerProps) => React.JSX.Element>;

package/dist/types/Toast.d.ts

@@ -0,0 +1,48 @@
+import type { ReactNode } from 'react';
+/**
+ * Transient top-center banner: slides in, holds at full opacity, fades out,
+ * then reports done so the owner can unmount it. Re-showing the same text
+ * restarts the cycle when the owner remounts the component (key it by a
+ * per-show sequence). Rendered through a body portal so an owner inside a
+ * transformed or filtered ancestor cannot trap the fixed banner in that
+ * ancestor's box.
+ * With unchanged holdMs, parent rerenders do not extend the lifetime.
+ * Completion calls the latest onDone handler; fully faded actions receive no input.
+ *
+ * The hold is the owner's to set, because how long a banner has to stay
+ * depends on how much there is to read: a one-line limit lands in the default
+ * window, while a failure that names what broke does not. One value drives
+ * both the unmount timer and the stylesheet's fade delay — the stylesheet
+ * reads it as a custom property — so the two can no longer disagree and leave
+ * the banner unmounting mid-fade.
+ * @param props.text - resolved banner copy; the owner passes localized text.
+ * @param props.icon - optional leading glyph (e.g. a warning icon); ignored
+ * under `tone="success"`, which brings its own glyph.
+ * @param props.tone - 'success' renders the design's circled green check as
+ * the leading glyph; omitted, the icon seat keeps its warning tint.
+ * @param props.actions - optional inline actions continuing the sentence:
+ * each renders its plain-text `prefix` (a connective like 或) followed by its
+ * localized `label` as blue clickable text, flowing after `text` as one
+ * sentence. Each press is the owner's to handle (e.g. undo the reported
+ * change, then unmount the toast). The banner surface stays click-through —
+ * only the action text takes the pointer.
+ * @param props.holdMs - full-opacity hold before the fade; defaults to 3000.
+ * @param props.anchor - optional element whose horizontal center the banner
+ * follows (e.g. the composer card, so the banner centers over the chat column
+ * rather than the whole window); omitted, it centers on the viewport.
+ * @param props.onDone - called once the fade completes; unmount the toast here.
+ * @returns the floating banner.
+ */
+export declare function Toast({ text, icon, tone, anchor, holdMs, actions, onDone, }: {
+    text: string;
+    icon?: ReactNode;
+    tone?: 'success';
+    anchor?: HTMLElement | null;
+    holdMs?: number;
+    actions?: readonly {
+        label: string;
+        prefix?: string;
+        onClick: () => void;
+    }[];
+    onDone: () => void;
+}): import("react").ReactPortal;