@peasant-labs/fairtrade 0.0.1 → 0.0.2

package/dist/lib/types/StatTiles.d.ts

@@ -0,0 +1,118 @@
+/**
+ * StatTile — one KPI: a mono eyebrow label, a big tabular display number, an optional sub line.
+ *
+ * @param {object} props
+ * @param {string} props.label - the metric name (lowercase chrome; e.g. "transcripts").
+ * @param {React.ReactNode} props.value - the headline figure (USER CONTENT — pre-formatted, e.g. "4.2M").
+ * @param {React.ReactNode} [props.sub] - an optional secondary line under the value (e.g. "9,610 turns").
+ * @param {React.ComponentType<{className?: string}>} [props.icon] - optional lucide icon for the label row.
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function StatTile({ label, value, sub, icon: Icon, className, ...rest }: {
+    label: string;
+    value: React.ReactNode;
+    sub?: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    className?: string;
+}): any;
+/**
+ * @typedef {object} TileSpec
+ * @property {string} key - stable key for the tile.
+ * @property {string} label - the metric name.
+ * @property {React.ReactNode} value - the headline figure.
+ * @property {React.ReactNode} [sub] - optional sub line.
+ * @property {React.ComponentType<{className?: string}>} [icon] - optional label icon.
+ */
+/**
+ * StatGrid — a responsive grid of StatTiles with a STABLE, capped column count (1→4 across
+ * breakpoints) so tiles keep equal widths and their eyebrows wrap consistently. The grid keys
+ * off its own width via a thin query-container wrapper (an element cannot query a container it
+ * establishes itself), so it stays correct wherever it is dropped — not just at the page width.
+ *
+ * @param {object} props
+ * @param {TileSpec[]} props.tiles - the KPI tiles to render, in order.
+ * @param {string} [props.className] - extra classes appended to the grid.
+ */
+export function StatGrid({ tiles, className, ...rest }: {
+    tiles: TileSpec[];
+    className?: string;
+}): any;
+/**
+ * GovTile — a governance fact: a mono eyebrow label, an icon, and a value that may carry one
+ * scarce earth-tone accent (e.g. amber for a "members only" / scarce policy). The value is mono,
+ * not the big display number — governance reads as a stated setting, not a metric.
+ *
+ * @param {object} props
+ * @param {string} props.label - the governance dimension (e.g. "access", "your role").
+ * @param {React.ReactNode} props.value - the setting (USER CONTENT — e.g. "members only", "contributor").
+ * @param {React.ComponentType<{className?: string}>} [props.icon] - optional lucide icon for the label row.
+ * @param {'amber'|'teal'|'olive'|'clay'|'mauve'} [props.tone] - optional earth-tone accent on the value.
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function GovTile({ label, value, icon: Icon, tone, className, ...rest }: {
+    label: string;
+    value: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    tone?: "amber" | "teal" | "olive" | "clay" | "mauve";
+    className?: string;
+}): any;
+/**
+ * @typedef {object} ProviderDatum
+ * @property {string} label - provider name (USER CONTENT — case preserved; e.g. "claude-code").
+ * @property {number} value - this provider's count.
+ */
+/**
+ * ProviderBars — a labeled horizontal distribution. Each row is a provider name, a monochrome bar
+ * whose width is its share of `total`, and a tabular %. Bars are one ink weight (no per-row hue):
+ * the eye reads length + label + the written %, so the distribution survives greyscale and AT.
+ *
+ * @param {object} props
+ * @param {ProviderDatum[]} props.data - the providers, in the order to display (caller pre-sorts).
+ * @param {number} [props.total] - the denominator for the shares; defaults to the sum of values.
+ * @param {string} [props.label='provider distribution'] - accessible name for the list (lowercase chrome).
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export function ProviderBars({ data, total, label, className, ...rest }: {
+    data: ProviderDatum[];
+    total?: number;
+    label?: string;
+    className?: string;
+}): any;
+export type TileSpec = {
+    /**
+     * - stable key for the tile.
+     */
+    key: string;
+    /**
+     * - the metric name.
+     */
+    label: string;
+    /**
+     * - the headline figure.
+     */
+    value: React.ReactNode;
+    /**
+     * - optional sub line.
+     */
+    sub?: React.ReactNode;
+    /**
+     * - optional label icon.
+     */
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+};
+export type ProviderDatum = {
+    /**
+     * - provider name (USER CONTENT — case preserved; e.g. "claude-code").
+     */
+    label: string;
+    /**
+     * - this provider's count.
+     */
+    value: number;
+};

package/dist/lib/types/StepWizard.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @typedef {Object} WizardStep
+ * @property {string} id     stable id for the step (aria wiring + completed/reachable sets)
+ * @property {React.ReactNode} label  the step's lowercase chrome label, shown under its number
+ */
+/**
+ * The rail alone: numbered square markers joined by connector lines. Pure/controlled — it owns no
+ * state. current = amber fill + bold near-black number + aria-current="step"; completed = olive +
+ * check glyph (clickable to jump back); future/unreachable = hairline + --ink-4 + aria-disabled
+ * (not clickable). Completed steps are always reachable.
+ *
+ * @param {Object} props
+ * @param {WizardStep[]} props.steps        the ordered steps
+ * @param {string} props.current            id of the active step
+ * @param {Set<string>} [props.completed]   ids of finished steps (olive + check, jump-back enabled)
+ * @param {Set<string>} [props.reachable]   ids the user may jump to (the gate). current + completed are implicitly reachable
+ * @param {(id: string) => void} [props.onJump]  called with a step id when a reachable/complete marker is activated
+ * @param {string} [props['aria-label']]    accessible name for the rail (default "progress")
+ */
+export function StepIndicator({ steps, current, completed, reachable, onJump, "aria-label": ariaLabel, }: {
+    steps: WizardStep[];
+    current: string;
+    completed?: Set<string>;
+    reachable?: Set<string>;
+    onJump?: (id: string) => void;
+}): any;
+/**
+ * @typedef {Object} WizardBodyArgs
+ * @property {WizardStep} step      the active step descriptor
+ * @property {number} index         its zero-based position
+ * @property {boolean} isLast       whether it's the final step
+ * @property {(valid: boolean) => void} setValid  report whether the step may advance (gates continue)
+ */
+/**
+ * Uncontrolled wizard: the rail + a per-step body slot + a sticky footer action bar.
+ * Tracks current / completed / reachable internally. Continue advances, marks the step complete,
+ * and unlocks the next step; on the last step its primary action reads "submit" and fires
+ * onComplete. Back is enabled on every step except the first.
+ *
+ * Step bodies come from either `children` (an array, one node per step — index-aligned to `steps`)
+ * or a `renderStep` render-prop called with {step, index, isLast, setValid}. A step is advanceable
+ * unless its render-prop has reported setValid(false); plain-children bodies are always valid.
+ *
+ * @param {Object} props
+ * @param {WizardStep[]} props.steps   the ordered steps (>= 1)
+ * @param {(args: { completed: Set<string> }) => void} [props.onComplete]  fired when the last step's submit is activated
+ * @param {(args: WizardBodyArgs) => React.ReactNode} [props.renderStep]   render-prop for the active step's body
+ * @param {React.ReactNode[]} [props.children]  index-aligned step bodies (alternative to renderStep)
+ * @param {string} [props.continueLabel='continue']  primary label for non-final steps
+ * @param {string} [props.submitLabel='submit']      primary label for the final step
+ * @param {string} [props.backLabel='back']          secondary (back) label
+ * @param {string} [props['aria-label']]  accessible name for the rail
+ */
+export default function StepWizard({ steps, onComplete, renderStep, children, continueLabel, submitLabel, backLabel, "aria-label": ariaLabel, }: {
+    steps: WizardStep[];
+    onComplete?: (args: {
+        completed: Set<string>;
+    }) => void;
+    renderStep?: (args: WizardBodyArgs) => React.ReactNode;
+    children?: React.ReactNode[];
+    continueLabel?: string;
+    submitLabel?: string;
+    backLabel?: string;
+}): any;
+export type WizardStep = {
+    /**
+     * stable id for the step (aria wiring + completed/reachable sets)
+     */
+    id: string;
+    /**
+     * the step's lowercase chrome label, shown under its number
+     */
+    label: React.ReactNode;
+};
+export type WizardBodyArgs = {
+    /**
+     * the active step descriptor
+     */
+    step: WizardStep;
+    /**
+     * its zero-based position
+     */
+    index: number;
+    /**
+     * whether it's the final step
+     */
+    isLast: boolean;
+    /**
+     * report whether the step may advance (gates continue)
+     */
+    setValid: (valid: boolean) => void;
+};

package/dist/lib/types/StepsWaterfall.d.ts

@@ -0,0 +1,67 @@
+/** Human-readable ms duration: "4.2s", "42s", "2m 14s", "1.5h". Tabular-friendly, no leading zeros. */
+export function formatDuration(ms: any): string;
+/**
+ * @typedef {object} Task
+ * @property {string} id - stable key; passed back to onJump (e.g. the prompt turn id).
+ * @property {number} [index] - the displayed task number (#1). Falls back to row order + 1.
+ * @property {string} prompt - the user prompt that opened the task (USER CONTENT — case preserved).
+ * @property {number} durationMs - how long the task took, in ms (drives the bar + the label).
+ * @property {number} [tools] - tool calls in the task (shown as "n tools" when no `turns`).
+ * @property {number} [turns] - assistant turns in the task (shown as "n turns").
+ * @property {'ok'|'error'} [outcome] - 'error' draws the clay marker + the "error" word/icon.
+ * @property {string} [error] - a short error label; shown in place of "error" when present.
+ */
+/**
+ * StepsWaterfall — render `tasks` as a duration waterfall: a header (total + count + collapse-all)
+ * over a list of selectable rows, each with a monochrome duration bar.
+ *
+ * @param {object} props
+ * @param {Task[]} props.tasks - the tasks, in order; one row each.
+ * @param {(id: string) => void} [props.onJump] - called with a task id when its row is chosen.
+ * @param {number} [props.totalMs] - total session time; defaults to the sum of task durations.
+ * @param {boolean} [props.defaultCollapsed=false] - start with the rows collapsed.
+ * @param {string} [props.label='steps by duration'] - accessible name for the list (lowercase chrome).
+ * @param {string} [props.className] - extra classes appended to the root.
+ */
+export default function StepsWaterfall({ tasks, onJump, totalMs, defaultCollapsed, label, className, ...rest }: {
+    tasks: Task[];
+    onJump?: (id: string) => void;
+    totalMs?: number;
+    defaultCollapsed?: boolean;
+    label?: string;
+    className?: string;
+}): any;
+export type Task = {
+    /**
+     * - stable key; passed back to onJump (e.g. the prompt turn id).
+     */
+    id: string;
+    /**
+     * - the displayed task number (#1). Falls back to row order + 1.
+     */
+    index?: number;
+    /**
+     * - the user prompt that opened the task (USER CONTENT — case preserved).
+     */
+    prompt: string;
+    /**
+     * - how long the task took, in ms (drives the bar + the label).
+     */
+    durationMs: number;
+    /**
+     * - tool calls in the task (shown as "n tools" when no `turns`).
+     */
+    tools?: number;
+    /**
+     * - assistant turns in the task (shown as "n turns").
+     */
+    turns?: number;
+    /**
+     * - 'error' draws the clay marker + the "error" word/icon.
+     */
+    outcome?: "ok" | "error";
+    /**
+     * - a short error label; shown in place of "error" when present.
+     */
+    error?: string;
+};

package/dist/lib/types/Switch.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @typedef {Object} SwitchProps
+ * @property {boolean} [checked]        controlled on/off state; pair with onChange.
+ * @property {boolean} [defaultChecked=false] initial state when uncontrolled.
+ * @property {(next: boolean) => void} [onChange] called with the next state on toggle.
+ * @property {boolean} [disabled=false] real `disabled` attribute (dim, not focusable).
+ * @property {boolean} [busy=false]     sets aria-busy; pairs with an aria-live marker.
+ * @property {React.ReactNode} [label]  text rendered in the associated .sw-label.
+ * @property {string} [onText='on']     state-marker text shown when checked.
+ * @property {string} [offText='off']   state-marker text shown when unchecked.
+ * @property {React.ComponentType<{size?: number}>} [stateIcon] override icon for the
+ *           .sw-state marker; defaults to CircleCheck (on) / Circle (off).
+ * @property {string} [id]              id for the control; links the label's `for`.
+ */
+/**
+ * @param {SwitchProps} props
+ */
+export default function Switch({ checked, defaultChecked, onChange, disabled, busy, label, onText, offText, stateIcon: StateIcon, id, }: SwitchProps): any;
+export type SwitchProps = {
+    /**
+     * controlled on/off state; pair with onChange.
+     */
+    checked?: boolean;
+    /**
+     * initial state when uncontrolled.
+     */
+    defaultChecked?: boolean;
+    /**
+     * called with the next state on toggle.
+     */
+    onChange?: (next: boolean) => void;
+    /**
+     * real `disabled` attribute (dim, not focusable).
+     */
+    disabled?: boolean;
+    /**
+     * sets aria-busy; pairs with an aria-live marker.
+     */
+    busy?: boolean;
+    /**
+     * text rendered in the associated .sw-label.
+     */
+    label?: React.ReactNode;
+    /**
+     * state-marker text shown when checked.
+     */
+    onText?: string;
+    /**
+     * state-marker text shown when unchecked.
+     */
+    offText?: string;
+    /**
+     * override icon for the
+     * .sw-state marker; defaults to CircleCheck (on) / Circle (off).
+     */
+    stateIcon?: React.ComponentType<{
+        size?: number;
+    }>;
+    /**
+     * id for the control; links the label's `for`.
+     */
+    id?: string;
+};

package/dist/lib/types/Tabs.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @typedef {Object} TabItem
+ * @property {string} id        stable id for the tab/panel pair (used for ids + aria wiring)
+ * @property {React.ReactNode} label  the tab's visible label; force-lowercased as ui chrome, so pass a section name, never user content / proper nouns
+ * @property {number} [count]   optional count shown in a .cnt badge after the label
+ * @property {React.ReactNode} content  the panel's content
+ */
+/**
+ * Self-contained ARIA tablist matching the trails-section specimen. Renders a
+ * `role="tablist".tabs` of `role="tab".tab` buttons (roving tabindex, `.active`
+ * on the selected tab, optional `.cnt` count) controlling `role="tabpanel".tabpanel`
+ * regions whose `hidden` attribute is toggled. Keyboard: Arrow/Home/End move
+ * selection (also focusing the tab), click selects + focuses. Ports the delegated
+ * logic from App.jsx's tablist useEffect.
+ *
+ * Supports controlled (`value` + `onChange`) and uncontrolled (`defaultTab`) use.
+ *
+ * @param {Object} props
+ * @param {TabItem[]} props.tabs           the tabs to render
+ * @param {string} [props.defaultTab]      initial selected tab id (uncontrolled; defaults to tabs[0].id)
+ * @param {string} [props.value]           selected tab id (controlled)
+ * @param {(id: string) => void} [props.onChange]  called with the newly selected tab id
+ * @param {string} [props['aria-label']]   accessible name for the tablist (default "tabs")
+ */
+export default function Tabs({ tabs, defaultTab, value, onChange, "aria-label": ariaLabel }: {
+    tabs: TabItem[];
+    defaultTab?: string;
+    value?: string;
+    onChange?: (id: string) => void;
+}): any;
+export type TabItem = {
+    /**
+     * stable id for the tab/panel pair (used for ids + aria wiring)
+     */
+    id: string;
+    /**
+     * the tab's visible label; force-lowercased as ui chrome, so pass a section name, never user content / proper nouns
+     */
+    label: React.ReactNode;
+    /**
+     * optional count shown in a .cnt badge after the label
+     */
+    count?: number;
+    /**
+     * the panel's content
+     */
+    content: React.ReactNode;
+};

package/dist/lib/types/TimeStrip.d.ts

@@ -0,0 +1,12 @@
+export function TimeStrip({ buckets, value, defaultValue, onScrub, branches, label, maxBranchChips, className, ...rest }: {
+    [x: string]: any;
+    buckets?: any[];
+    value: any;
+    defaultValue?: number;
+    onScrub: any;
+    branches?: any[];
+    label?: string;
+    maxBranchChips?: number;
+    className?: string;
+}): any;
+export default TimeStrip;

package/dist/lib/types/Timeline.d.ts

@@ -0,0 +1,192 @@
+/**
+ * ThinkingBlock — a collapsible reasoning panel. Controlled when `open`/`onToggle`
+ * are passed, otherwise it self-manages. Header is a real <button aria-expanded>;
+ * the body lazy-mounts on open so collapsed reasoning is absent from the a11y tree.
+ *
+ * @param {Object} props
+ * @param {Thinking} props.block            the reasoning block (words + text)
+ * @param {boolean} [props.open]            controlled open state
+ * @param {() => void} [props.onToggle]     controlled toggle handler
+ */
+export function ThinkingBlock({ block, open: openProp, onToggle }: {
+    block: Thinking;
+    open?: boolean;
+    onToggle?: () => void;
+}): any;
+/**
+ * ToolCall — one collapsible tool call. Controlled when `open`/`onToggle` are passed
+ * (lets a host own expand-all), otherwise self-managed. Header is a real
+ * <button aria-expanded>; the body lazy-mounts on open. `renderTool` overrides the
+ * built-in body dispatch.
+ *
+ * @param {Object} props
+ * @param {Tool} props.tool
+ * @param {number} [props.index]                     position, passed to renderTool
+ * @param {boolean} [props.open]                     controlled open state
+ * @param {() => void} [props.onToggle]              controlled toggle handler
+ * @param {(tool: Tool, i: number) => React.ReactNode} [props.renderTool]  custom body renderer
+ */
+export function ToolCall({ tool, index, open: openProp, onToggle, renderTool }: {
+    tool: Tool;
+    index?: number;
+    open?: boolean;
+    onToggle?: () => void;
+    renderTool?: (tool: Tool, i: number) => React.ReactNode;
+}): any;
+/**
+ * TimelineItem — renders one node on the spine, switching on `kind`. Owns the
+ * decorative dot, the role glyph + head meta and the body slot. Exported so a host
+ * can map its own array and compose custom containers.
+ *
+ * @param {Object} props
+ * @param {TimelineItem} props.item
+ * @param {(tool: Tool, i: number) => React.ReactNode} [props.renderTool]
+ * @param {(item: TimelineItem) => React.ReactNode} [props.renderBody]
+ */
+export function TimelineItem({ item, renderTool, renderBody }: {
+    item: TimelineItem;
+    renderTool?: (tool: Tool, i: number) => React.ReactNode;
+    renderBody?: (item: TimelineItem) => React.ReactNode;
+}): any;
+export type TimelineItem = {
+    id: string;
+    /**
+     * node type on the spine
+     */
+    kind: "turn" | "phase" | "checkpoint";
+    /**
+     * (kind: turn)
+     */
+    role?: "user" | "assistant" | "subagent" | "tool" | "system";
+    /**
+     * turn label e.g. '2a' (tabular)
+     */
+    label?: string;
+    /**
+     * 0 = main thread; > 0 = subagent inset
+     */
+    depth?: number;
+    /**
+     * subagent name when depth > 0
+     */
+    subagent?: string;
+    /**
+     * relative, e.g. '8m ago'
+     */
+    time?: string;
+    /**
+     * absolute, used for title=
+     */
+    longTime?: string;
+    /**
+     * the turn text (passed to renderBody)
+     */
+    body?: string;
+    /**
+     * collapsible reasoning block
+     */
+    thinking?: Thinking;
+    /**
+     * collapsible tool calls
+     */
+    tools?: Tool[];
+    tokens?: {
+        in: number;
+        out: number;
+    };
+    /**
+     * turn surfaced a tool error
+     */
+    error?: boolean;
+    /**
+     * marks the last assistant turn; caps the spine below it
+     */
+    final?: boolean;
+    /**
+     * (kind: phase) e.g. 'debugging'
+     */
+    phaseLabel?: string;
+    /**
+     * lucide phase icon
+     */
+    icon?: React.ComponentType<any>;
+    /**
+     * 'turns 3–4 · 1 error'
+     */
+    range?: string;
+    /**
+     * (kind: checkpoint) commit hash
+     */
+    hash?: string;
+    /**
+     * commit message
+     */
+    msg?: string;
+    stat?: {
+        files: number;
+        adds: number;
+        dels: number;
+    };
+};
+/**
+ * Timeline — a vertical spine for a whole session: phase dividers, role-tinted
+ * turn nodes, collapsible thinking + tool calls, subagent insets and commit
+ * checkpoints, read top to bottom. The vertical sibling of the horizontal Steps
+ * wizard; they share no geometry. Role is carried by glyph + label, never tint
+ * alone; the spine stays continuous even through subagent insets.
+ *
+ * Emits `<ol class="tl" aria-label>` — turns are an ordered list so DOM order
+ * equals visual order equals conversation order. Renders an EmptyState-style
+ * `.empty` block when `items` is empty.
+ *
+ * @param {Object} props
+ * @param {TimelineItem[]} [props.items=[]]                           ordered top->bottom event stream
+ * @param {(tool: Tool, i: number) => React.ReactNode} [props.renderTool]  per-tool body override
+ * @param {(item: TimelineItem) => React.ReactNode} [props.renderBody]     per-role body override
+ * @param {boolean} [props.dense=false]                              compact rhythm for sidebars
+ * @param {string} [props.ariaLabel='conversation timeline']         label for the <ol> landmark
+ */
+export default function Timeline({ items, renderTool, renderBody, dense, ariaLabel }: {
+    items?: TimelineItem[];
+    renderTool?: (tool: Tool, i: number) => React.ReactNode;
+    renderBody?: (item: TimelineItem) => React.ReactNode;
+    dense?: boolean;
+    ariaLabel?: string;
+}): any;
+export type Thinking = {
+    /**
+     * word count shown next to the toggle (tabular)
+     */
+    words: number;
+    /**
+     * the reasoning text (kept in original case)
+     */
+    text: string;
+};
+export type Tool = {
+    id: string;
+    /**
+     * switch for the built-in renderer
+     */
+    kind: "read" | "grep" | "edit" | "write" | "bash" | "task" | "webfetch" | string;
+    /**
+     * content-case label e.g. 'Read' (NEVER lowercased)
+     */
+    name: string;
+    /**
+     * one-line summary shown while collapsed
+     */
+    preview: string;
+    /**
+     * e.g. '4.1s' (tabular)
+     */
+    duration?: string;
+    /**
+     * bash exit code; !== 0 surfaces an error pill + tints the dot
+     * kind-specific payload: read{path,lines,excerpt} · grep{pattern,scope,glob,matches,results}
+     * · edit{path,adds,dels,hunk[]} · bash{command,description,stdout,exit,duration}
+     * · webfetch{url,prompt,result} · task{agent,status,task,owner,promptBody,result}
+     * · default{args,result}
+     */
+    exit?: number;
+};

package/dist/lib/types/ToastHost.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @typedef {Object} ToastOpts
+ * @property {React.ReactNode} [title]    the title line; defaults to the tone label.
+ * @property {'ok'|'err'} [variant]       tone; defaults per method ('ok' for show()).
+ * @property {React.ComponentType} [icon] override the leading lucide glyph.
+ * @property {number} [duration]          per-toast auto-dismiss ms; 0/Infinity = sticky.
+ * @property {string} [closeLabel]        aria-label for the dismiss button.
+ * @property {string} [id]                supply to dedupe / target with update().
+ */
+/**
+ * ToastProvider — wraps a subtree and renders the fixed stacking host. children that
+ * call useToast() get a stable imperative api (memoised; identity never changes).
+ *
+ * @param {Object} props
+ * @param {React.ReactNode} props.children          the app subtree that may call useToast().
+ * @param {'bottom-right'|'bottom-left'|'top-right'|'top-left'|'bottom-center'|'top-center'} [props.placement='bottom-right']
+ *        which corner the fixed region pins to and the edge new toasts enter from.
+ * @param {number} [props.max=4]                    cap on simultaneously-visible toasts.
+ * @param {number} [props.duration=5000]            default auto-dismiss ms; 0/Infinity = sticky.
+ * @param {boolean} [props.inline=false]            pin the host absolutely inside a relative
+ *        container (for an in-frame doc/story example) instead of fixed to the viewport.
+ */
+export function ToastProvider({ children, placement, max, duration, inline, }: {
+    children: React.ReactNode;
+    placement?: "bottom-right" | "bottom-left" | "top-right" | "top-left" | "bottom-center" | "top-center";
+    max?: number;
+    duration?: number;
+    inline?: boolean;
+}): any;
+/**
+ * useToast — the imperative api object from the nearest ToastProvider. throws a clear
+ * lowercase error when called outside a provider so a missing host is caught in dev.
+ * @returns {{ ok: Function, err: Function, show: Function, dismiss: Function, dismissAll: Function, update: Function, promise: Function }}
+ */
+export function useToast(): {
+    ok: Function;
+    err: Function;
+    show: Function;
+    dismiss: Function;
+    dismissAll: Function;
+    update: Function;
+    promise: Function;
+};
+export default ToastProvider;
+export type ToastOpts = {
+    /**
+     * the title line; defaults to the tone label.
+     */
+    title?: React.ReactNode;
+    /**
+     * tone; defaults per method ('ok' for show()).
+     */
+    variant?: "ok" | "err";
+    /**
+     * override the leading lucide glyph.
+     */
+    icon?: React.ComponentType;
+    /**
+     * per-toast auto-dismiss ms; 0/Infinity = sticky.
+     */
+    duration?: number;
+    /**
+     * aria-label for the dismiss button.
+     */
+    closeLabel?: string;
+    /**
+     * supply to dedupe / target with update().
+     */
+    id?: string;
+};