@flytedan/flytebot-design-system 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,2727 @@
+import * as React from 'react';
+
+/**
+ * The one action primitive. Primary is a gradient; everything else is flat.
+ * Never more than one primary per view.
+ */
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+    /** primary = the one action. brandSoft = marketing CTA at >=19px/700 only (AA large-text). */
+    variant?: "primary" | "brandSoft" | "secondary" | "ghost" | "danger" | "link";
+    size?: "sm" | "md" | "lg";
+    /** Phosphor icon name, leading, e.g. "plus" */
+    icon?: string;
+    /** Phosphor icon name, trailing */
+    trailingIcon?: string;
+    /** The site's signature inset-circle arrow. Use on hero CTAs only. */
+    arrow?: boolean;
+    /** Label stays put; a spinner replaces the leading icon. */
+    loading?: boolean;
+    block?: boolean;
+    as?: "button" | "a";
+}
+declare function Button({ children, variant, size, icon, trailingIcon, arrow, loading, disabled, block, as, className, ...rest }: ButtonProps): React.JSX.Element;
+
+/** A square action carrying only a Phosphor glyph. Always needs a label for a11y. */
+interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Phosphor icon name, e.g. "dots-three-vertical" */
+    icon: string;
+    /** Accessible name, also the title tooltip. Required. */
+    label: string;
+    size?: "sm" | "md" | "lg";
+    variant?: "ghost" | "outline";
+    round?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+declare function IconButton({ icon, label, size, variant, round, disabled, className, ...rest }: IconButtonProps): React.JSX.Element;
+
+type Placement = "bottom-start" | "bottom-end" | "bottom-center" | "top-start" | "top-end" | "top-center";
+interface PopoverProps {
+    open?: boolean;
+    anchorRef: React.RefObject<HTMLElement>;
+    onClose?: () => void;
+    placement?: Placement;
+    offset?: number;
+    matchWidth?: boolean;
+    width?: number;
+    minWidth?: number;
+    maxHeight?: number;
+    padded?: boolean;
+    role?: string;
+    label?: string;
+    closeOnOutside?: boolean;
+    closeOnEscape?: boolean;
+    returnFocus?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+}
+interface PopoverPosition {
+    left: number;
+    width: number | undefined;
+    minWidth: number | undefined;
+    top: number | null;
+    bottom: number | null;
+    maxH: number;
+    side: "top" | "bottom";
+    anchorWidth: number;
+}
+/**
+ * Fixed-position layer geometry for an anchored surface. Flips side when the
+ * preferred one doesn't fit, clamps to the viewport, and re-measures on scroll
+ * and resize (capture phase, so it tracks inside scrolling panels too).
+ */
+declare function usePopoverPosition(open: boolean, anchorRef: React.RefObject<HTMLElement>, opts?: Partial<PopoverProps> & {
+    estHeight?: number;
+    estWidth?: number;
+}): PopoverPosition | null;
+/**
+ * An anchored floating surface: menus, pickers, disclosure panels, meters.
+ * Owns nothing but placement, dismissal and focus return — the content is yours.
+ */
+declare function Popover({ open, anchorRef, onClose, placement, offset, matchWidth, width, minWidth, maxHeight, padded, role, label, closeOnOutside, closeOnEscape, returnFocus, className, style, children, }: PopoverProps): React.ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+interface MenuItem {
+    id?: string;
+    label?: React.ReactNode;
+    icon?: string;
+    description?: React.ReactNode;
+    meta?: React.ReactNode;
+    /** A key HINT. Renders a cap, binds nothing. */
+    shortcut?: React.ReactNode;
+    /** Present (true/false) makes the row a menuitemradio with a check column. */
+    checked?: boolean;
+    disabled?: boolean;
+    submenu?: MenuItem[];
+    /** A secondary action pinned to the row (e.g. delete). Rendered as a sibling button, so it is keyboard-reachable and does not nest inside the row button. */
+    trailingAction?: {
+        icon?: string;
+        label: string;
+        danger?: boolean;
+        closeOnSelect?: boolean;
+        onSelect?: (item: MenuItem) => void;
+    };
+    onSelect?: (item: MenuItem) => void;
+    kind?: "separator" | "section" | "custom";
+    render?: () => React.ReactNode;
+}
+interface MenuProps {
+    items: MenuItem[];
+    onSelect?: (item: MenuItem) => void;
+    onClose?: () => void;
+    autoFocus?: boolean;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    className?: string;
+}
+/**
+ * A keyboard-complete menu list. Items may be:
+ *   {id,label,icon,description,meta,shortcut,checked,disabled,submenu,onSelect}
+ *   {kind:"separator"} · {kind:"section",label} · {kind:"custom",render}
+ * `shortcut` is a HINT — it renders a cap and binds nothing.
+ */
+declare function Menu({ items, onSelect, onClose, autoFocus, className, footer, header }: MenuProps): React.JSX.Element;
+interface MenuButtonProps extends Omit<MenuProps, "onClose" | "autoFocus"> {
+    label?: React.ReactNode;
+    icon?: string;
+    trailingIcon?: string | null;
+    placement?: Placement;
+    variant?: "chip" | "ghost";
+    size?: "sm" | "md";
+    disabled?: boolean;
+    title?: string;
+    ariaLabel?: string;
+    width?: number;
+    minWidth?: number;
+    maxHeight?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Trigger + menu in one: a compact chip that opens an anchored Menu.
+ * Used for model pickers, row overflow actions, view switchers.
+ */
+declare function MenuButton({ label, icon, trailingIcon, items, onSelect, placement, variant, size, disabled, title, ariaLabel, width, minWidth, maxHeight, className, children, header, footer, }: MenuButtonProps): React.JSX.Element;
+
+/** Two to four mutually exclusive views — density, date range, light/dark. */
+interface SegmentedControlProps {
+    options: Array<string | {
+        value: string;
+        label: string;
+    }>;
+    value?: string;
+    onChange?: (value: string) => void;
+    className?: string;
+}
+declare function SegmentedControl({ options, value, onChange, className, ...rest }: SegmentedControlProps): React.JSX.Element;
+
+/**
+ * The container. White, 12px radius, hairline border, low soft shadow, and a
+ * divider under the header — that divider is the signature detail on flytedesk.com.
+ */
+interface CardProps {
+    title?: React.ReactNode;
+    /** Right-aligned control in the header — usually an IconButton or a link Button. */
+    action?: React.ReactNode;
+    footer?: React.ReactNode;
+    children?: React.ReactNode;
+    elevation?: "flat" | "rest" | "raised";
+    hoverable?: boolean;
+    /** Set false to let children run edge to edge (tables, images). */
+    padded?: boolean;
+    className?: string;
+}
+declare function Card({ title, action, footer, children, elevation, hoverable, padded, className, ...rest }: CardProps): React.JSX.Element;
+interface CardRowProps {
+    label: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function CardRow({ label, children, className }: CardRowProps): React.JSX.Element;
+
+/**
+ * The system's main density valve: a large, calm trigger row that opens a panel.
+ * Prefer this over tabs or a second page when a screen has more than it can show.
+ */
+interface CollapsibleProps {
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    /** Right-aligned status — a Badge or CsiBadge. */
+    badge?: React.ReactNode;
+    /** Phosphor icon name shown in a soft brand chip on the left. */
+    icon?: string;
+    defaultOpen?: boolean;
+    /** Pass with onToggle for controlled use. */
+    open?: boolean;
+    onToggle?: (open: boolean) => void;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function Collapsible({ title, subtitle, badge, icon, defaultOpen, open, onToggle, children, className, ...rest }: CollapsibleProps): React.JSX.Element;
+
+/** A right-side panel for detail and editing without losing the list behind it. */
+interface DrawerProps {
+    open?: boolean;
+    title?: React.ReactNode;
+    onClose?: () => void;
+    /** Plain content, or a render function receiving `close` — call it to trigger the closing animation before onClose fires. */
+    footer?: React.ReactNode | ((close: () => void) => React.ReactNode);
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function Drawer({ open, title, onClose, footer, children, className, ...rest }: DrawerProps): React.ReactPortal | null;
+
+/** A focused decision on a scrim. Max 560px, 760 with `wide` for data. Escape closes. */
+interface ModalProps {
+    open?: boolean;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    onClose?: () => void;
+    /** Plain content, or a render function receiving `close` — call it to trigger the closing animation before onClose fires. */
+    footer?: React.ReactNode | ((close: () => void) => React.ReactNode);
+    /** 760px — for tables and side-by-side comparisons. */
+    wide?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function Modal({ open, title, description, onClose, footer, wide, children, className, ...rest }: ModalProps): React.ReactPortal | null;
+
+/**
+ * The async contract for one region of a screen. Four states, one component:
+ * loading (skeleton), refreshing (previous data stays visible, dimmed and inert),
+ * ready, empty/error.
+ */
+interface LoadingRegionProps {
+    state?: "loading" | "refreshing" | "ready" | "empty" | "error";
+    /** What to show before first data. Mirror the ready layout. */
+    skeleton?: React.ReactNode;
+    children?: React.ReactNode;
+    /** Announced to screen readers while busy. */
+    label?: string;
+    error?: string;
+    onRetry?: () => void;
+    className?: string;
+}
+declare function LoadingRegion({ state, skeleton, children, label, error, onRetry, className, ...rest }: LoadingRegionProps): React.JSX.Element;
+
+/** Determinate or indeterminate bar for a known long job — uploads, exports, plan builds. */
+interface ProgressBarProps {
+    /** 0-100. Omit for indeterminate. */
+    value?: number;
+    label?: string;
+    showValue?: boolean;
+    className?: string;
+}
+declare function ProgressBar({ value, label, showValue, className, ...rest }: ProgressBarProps): React.JSX.Element;
+
+/**
+ * The shape data will occupy, shown before the first payload lands.
+ * Skeletons mirror the real layout so nothing shifts on arrival.
+ */
+interface SkeletonProps {
+    w?: number | string;
+    h?: number | string;
+    shape?: "block" | "text" | "circle" | "card";
+    radius?: string;
+    style?: React.CSSProperties;
+    className?: string;
+}
+declare function Skeleton({ w, h, shape, radius, style, className, ...rest }: SkeletonProps): React.JSX.Element;
+interface SkeletonTextProps {
+    lines?: number;
+    /** Per-line widths, cycled. Ragged widths read as text; equal widths read as a bug. */
+    width?: string[];
+    size?: number;
+    gap?: number;
+    className?: string;
+}
+declare function SkeletonText({ lines, width, size, gap, className }: SkeletonTextProps): React.JSX.Element;
+
+/** A small indeterminate indicator. For inline waits only — never over a whole page. */
+interface SpinnerProps {
+    size?: "sm" | "md" | "lg";
+    label?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+declare function Spinner({ size, label, className, style, ...rest }: SpinnerProps): React.JSX.Element;
+
+/**
+ * The app's 264px left rail. Grouped items under overline headers; the active item
+ * takes a soft blue fill and deep blue label. Collapses off-canvas below 1024px.
+ */
+interface SidebarNavItem {
+    value: string;
+    label: string;
+    /** Phosphor icon name */
+    icon: string;
+    count?: number;
+    /** Count still loading — shows a small skeleton instead of a number. */
+    loading?: boolean;
+    /** Member lacks the permission — shows a lock marker. Still navigable; the screen explains. */
+    locked?: boolean;
+    /** Designed but the backend is not wired — shows a construction marker. Still navigable;
+     *  the screen renders inert behind a coming-soon banner. */
+    preview?: boolean;
+}
+interface SidebarNavProps {
+    brand?: React.ReactNode;
+    groups: Array<{
+        label?: string;
+        items: SidebarNavItem[];
+    }>;
+    current?: string;
+    onNavigate?: (value: string) => void;
+    footer?: React.ReactNode;
+    /** Mobile: slides the off-canvas rail in. */
+    open?: boolean;
+    className?: string;
+}
+declare function SidebarNav({ brand, groups, current, onNavigate, footer, open, className, ...rest }: SidebarNavProps): React.JSX.Element;
+
+/**
+ * Places within one screen. Underline only — no pill tabs in the product.
+ */
+interface TabsProps {
+    tabs: Array<string | {
+        value: string;
+        label: string;
+        count?: number;
+    }>;
+    value?: string;
+    onChange?: (value: string) => void;
+    className?: string;
+}
+declare function Tabs({ tabs, value, onChange, className, ...rest }: TabsProps): React.JSX.Element;
+
+/** 60px app header: breadcrumb left, actions right, and a 2px route loader along its top edge. */
+interface TopbarProps {
+    crumbs?: Array<{
+        label: string;
+        href?: string;
+    }>;
+    actions?: React.ReactNode;
+    /** Shows the indeterminate route loader on the top edge. */
+    loading?: boolean;
+    /** Mobile menu handler — renders the hamburger. */
+    onMenu?: () => void;
+    className?: string;
+}
+declare function Topbar({ crumbs, actions, loading, onMenu, className, ...rest }: TopbarProps): React.JSX.Element;
+
+/** A person or organisation mark. Initials on a soft brand tint when no image exists. */
+interface AvatarProps {
+    name?: string;
+    src?: string;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+declare function Avatar({ name, src, size, className, ...rest }: AvatarProps): React.JSX.Element;
+interface AvatarStackProps {
+    people: Array<string | {
+        name: string;
+        src?: string;
+    }>;
+    size?: "sm" | "md" | "lg";
+    max?: number;
+    className?: string;
+}
+declare function AvatarStack({ people, size, max, className }: AvatarStackProps): React.JSX.Element;
+
+/**
+ * A pill of state. Badges never carry actions — if it is clickable it is a Tag.
+ */
+interface BadgeProps {
+    children?: React.ReactNode;
+    /** live = the site's blue gradient "Active". approved = its mint pill. count = the blue number chip. */
+    tone?: "neutral" | "info" | "success" | "warning" | "danger" | "live" | "approved" | "count";
+    dot?: boolean;
+    /** Phosphor icon name */
+    icon?: string;
+    className?: string;
+}
+declare function Badge({ children, tone, dot, icon, className, ...rest }: BadgeProps): React.JSX.Element;
+
+/** Says what will appear here, and offers exactly one button. */
+interface EmptyStateProps {
+    /** Phosphor icon name */
+    icon?: string;
+    title: React.ReactNode;
+    children?: React.ReactNode;
+    action?: React.ReactNode;
+    className?: string;
+}
+declare function EmptyState({ icon, title, children, action, className, ...rest }: EmptyStateProps): React.JSX.Element;
+
+/**
+ * A callout with a fixed structure: statement, then cost, then two actions.
+ * A flag without a number and a choice is not a flag — use plain body copy.
+ */
+interface FlagProps {
+    /** What is true. "Ohio State is Weak." */
+    statement: React.ReactNode;
+    /** What it costs to fix. "+$4,200 reaches Adequate." Rendered bold. */
+    cost?: React.ReactNode;
+    /** Two Buttons — the fix and the dismissal. */
+    actions?: React.ReactNode;
+    tone?: "info" | "success" | "warning" | "danger";
+    className?: string;
+}
+declare function Flag$1({ statement, cost, actions, tone, className, ...rest }: FlagProps): React.JSX.Element;
+
+/** A key hint that binds NOTHING — register the real shortcut separately. */
+interface KeyHintProps {
+    keys: string;
+    size?: "sm" | "md";
+    tone?: "quiet" | "solid";
+    className?: string;
+}
+/**
+ * A key hint. Renders a label and binds NOTHING — register the real shortcut
+ * separately, or the cap and the binding drift apart.
+ */
+declare function KeyHint({ keys, size, tone, className, ...rest }: KeyHintProps): React.JSX.Element;
+/** The platform modifier as text, for prose: "⌘" or "Ctrl". */
+declare function modifierLabel(): string;
+/** True when the event carries the platform's primary modifier. */
+declare function hasModifier(e: KeyboardEvent | React.KeyboardEvent): boolean;
+
+/** A clickable chip — filters, selected campuses, applied channels. */
+interface TagProps {
+    children?: React.ReactNode;
+    icon?: string;
+    selected?: boolean;
+    onRemove?: () => void;
+    onClick?: () => void;
+    className?: string;
+}
+declare function Tag({ children, icon, selected, onRemove, onClick, className, ...rest }: TagProps): React.JSX.Element;
+
+/** Confirmation of something that already happened. Bottom-right, 5s, undo where reversible. */
+interface ToastProps {
+    title: React.ReactNode;
+    children?: React.ReactNode;
+    tone?: "success" | "error" | "info" | "loading";
+    onUndo?: () => void;
+    onDismiss?: () => void;
+    className?: string;
+}
+declare function Toast({ title, children, tone, onUndo, onDismiss, className, ...rest }: ToastProps): React.JSX.Element;
+
+/** A short clarification on hover or focus. Never the only place information lives. */
+interface TooltipProps {
+    label: React.ReactNode;
+    placement?: "top" | "bottom";
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function Tooltip({ label, placement, children, className }: TooltipProps): React.JSX.Element;
+
+interface ClampProps {
+    children?: React.ReactNode;
+    /** With maxChars, pass the raw string instead of children. */
+    text?: string;
+    maxChars?: number;
+    maxHeight?: number;
+    moreLabel?: string;
+    lessLabel?: string;
+    onToggle?: (open: boolean) => void;
+    className?: string;
+}
+/**
+ * Height- or character-clamped content with a Show more control.
+ * The control is a real button, always in the DOM when the content overflows.
+ */
+declare function Clamp({ children, text, maxChars, maxHeight, moreLabel, lessLabel, onToggle, className, }: ClampProps): React.JSX.Element;
+
+interface CsiMeterProps {
+    band: "weak" | "adequate" | "strong" | "dominant";
+    size?: number;
+    width?: number;
+    gap?: number;
+}
+declare function CsiMeter({ band, size, width, gap }: CsiMeterProps): React.JSX.Element;
+/**
+ * Campus Saturation Index — the product's signature encoding. Four ordered bands
+ * in a reserved teal ramp that appears nowhere else: blue is interaction, teal is
+ * saturation. Never color-only — the band name and a 4-segment meter always ship
+ * with the fill.
+ */
+interface CsiBadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    band: "weak" | "adequate" | "strong" | "dominant";
+    /** Cost per reachable person. Internal surfaces only — never client-facing. */
+    crp?: number;
+    size?: "compact" | "medium";
+    /** The "will become" state while a reallocation is being dragged: 70% opacity, dashed edge. */
+    preview?: boolean;
+    /** Amber dot marking a Weak campus that can be fixed. */
+    alert?: boolean;
+}
+declare function CsiBadge({ band, crp, size, preview, alert, className, ...rest }: CsiBadgeProps): React.JSX.Element;
+interface CsiHeroProps {
+    band: "weak" | "adequate" | "strong" | "dominant";
+    crp?: number;
+    label?: string;
+    className?: string;
+}
+declare function CsiHero({ band, crp, label, className }: CsiHeroProps): React.JSX.Element;
+
+/**
+ * The product's dense read surface. Sticky overline header, hairline rows, no zebra,
+ * numbers right-aligned and tabular. Renders its own skeleton rows so the table
+ * never collapses while data is in flight.
+ */
+interface DataTableColumn {
+    key: string;
+    label: string;
+    /** Right-aligned tabular figures. Never center a number. */
+    numeric?: boolean;
+    /** Set widths explicitly; auto layout shifts as data arrives. */
+    width?: string;
+    sortable?: boolean;
+    render?: (row: any) => React.ReactNode;
+}
+interface DataTableProps {
+    columns: DataTableColumn[];
+    rows: any[];
+    compact?: boolean;
+    selectedId?: string | number;
+    onRowClick?: (row: any) => void;
+    rowKey?: string;
+    /** First load: nothing on screen yet, so skeleton rows are drawn. */
+    loading?: boolean;
+    /** A re-query (sort, filter, page) while the PREVIOUS rows are still rendered. Dims them,
+     *  makes them inert and shows an "Updating…" pill, so nobody acts on superseded data. */
+    refreshing?: boolean;
+    skeletonRows?: number;
+    sort?: {
+        key: string;
+        dir: "asc" | "desc";
+    };
+    onSort?: (key: string) => void;
+    className?: string;
+}
+declare function DataTable({ columns, rows, compact, selectedId, onRowClick, rowKey, loading, refreshing, skeletonRows, sort, onSort, className, ...rest }: DataTableProps): React.JSX.Element;
+
+/**
+ * A flat figure tile — no shadow, no background color, never more than four in a row.
+ */
+interface StatTileProps extends React.HTMLAttributes<HTMLDivElement> {
+    label: string;
+    value?: React.ReactNode;
+    sub?: React.ReactNode;
+    /** "+12.4%" or "-3.1%" — colour and arrow follow the sign. */
+    delta?: string;
+    loading?: boolean;
+    /** Thin one-line variant for stat rows above tables. */
+    compact?: boolean;
+    className?: string;
+}
+declare function StatTile({ label, value, sub, delta, loading, compact, className, ...rest }: StatTileProps): React.JSX.Element;
+
+declare function languageLabel(lang?: string): string;
+/** Tokenise source into [{t, c}] where c is a token class or null for plain text. */
+declare function tokenize(src: string, lang?: string): Array<{
+    t: string;
+    c: string | null;
+}>;
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    filename?: string;
+    lineNumbers?: boolean;
+    wrap?: boolean;
+    /** Fold past this many lines. 0 disables. Default 26. */
+    collapseAfter?: number;
+    copyable?: boolean;
+    actions?: React.ReactNode;
+    className?: string;
+}
+/**
+ * A fenced code block: language label, copy, soft-wrap toggle, optional line
+ * numbers, and a fold for long listings.
+ */
+declare function CodeBlock({ code, language, filename, lineNumbers, wrap: wrapDefault, collapseAfter, copyable, actions, className, }: CodeBlockProps): React.JSX.Element;
+interface DiffBlockProps {
+    diff: string;
+    filename?: string;
+    language?: string;
+    collapseAfter?: number;
+    className?: string;
+}
+/**
+ * A unified diff. Renders +/- lines with their own gutters and a stat line —
+ * the shape a code change should always take in a transcript.
+ */
+declare function DiffBlock({ diff, filename, collapseAfter, className }: DiffBlockProps): React.JSX.Element;
+
+interface MarkdownProps {
+    source: string;
+    className?: string;
+    codeProps?: Partial<CodeBlockProps>;
+    allowImages?: boolean;
+    headingOffset?: number;
+    /** Renderer for `[^n]` markers. */
+    renderCitation?: (marker: string) => React.ReactNode;
+    onLinkClick?: (e: React.MouseEvent) => void;
+}
+/**
+ * Read-only markdown → React nodes. Headings, emphasis, links, lists (incl. task
+ * lists), quotes, tables, images, fenced code (handed to CodeBlock, `diff` to
+ * DiffBlock) and `[^n]` citation markers.
+ *
+ * Deliberately read-only: an editor in readonly mode carries a contenteditable,
+ * a context menu and popovers it will never use — per message.
+ */
+declare function Markdown({ source, className, codeProps, allowImages, headingOffset, renderCitation, onLinkClick, }: MarkdownProps): React.JSX.Element;
+/** Inline-only markdown, for labels and single-line contexts. */
+declare function MarkdownInline({ source, className, onLinkClick }: {
+    source: string;
+    className?: string;
+    onLinkClick?: (e: React.MouseEvent) => void;
+}): React.JSX.Element;
+/** Strip markdown to plain text — for copy actions, titles and previews. */
+declare function markdownToText(src: string): string;
+
+/**
+ * A segmented bar — budget split by channel, delivery against a flight.
+ * Unallocated space is hatched, so it looks unfinished rather than empty.
+ */
+interface MeterSegment {
+    label: string;
+    value: number;
+    /** Defaults to the categorical chart ramp in order. */
+    color?: string;
+}
+interface MeterProps {
+    segments: MeterSegment[];
+    unallocated?: number;
+    height?: number;
+    label?: string;
+    legend?: boolean;
+    className?: string;
+}
+declare function Meter({ segments, unallocated, height, label, legend, className }: MeterProps): React.JSX.Element;
+
+/**
+ * The standard footer for a server-driven table: range readout, rows-per-page,
+ * and windowed page navigation. Presentational only — it holds no state.
+ */
+interface PaginationProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** 1-indexed current page. */
+    page?: number;
+    pageSize?: number;
+    /** Total matching rows on the server, not the length of the current page. */
+    total?: number;
+    pageSizes?: number[];
+    onPageChange?: (page: number) => void;
+    /** Omit to hide the rows-per-page control. */
+    onPageSizeChange?: (pageSize: number) => void;
+    loading?: boolean;
+    /** Noun for the readout — "rows", "campuses", "placements". */
+    unit?: string;
+    className?: string;
+}
+/**
+ * Pagination — the standard footer for every server-driven table.
+ * Purely presentational: it reports intent through onPageChange / onPageSizeChange
+ * and never derives its own state, so it stays honest against a real endpoint.
+ */
+declare function Pagination({ page, pageSize, total, pageSizes, onPageChange, onPageSizeChange, loading, unit, className, ...rest }: PaginationProps): React.JSX.Element;
+
+/** "just now" · "4 min ago" · "in 4 min" · "Wed 5:00 PM" · "12 Mar" */
+declare function formatRelative(value: string | Date, now?: number): string;
+/** Absolute, for the title attribute. */
+declare function formatAbsolute(value: string | Date): string;
+/** Clock time only — "3:42 PM". */
+declare function formatClock(value: string | Date): string;
+/** ms → "1m 34s" · "12.4s" · "840ms" */
+declare function formatDuration(ms: number): string;
+interface RelativeTimeProps {
+    value: string | Date;
+    prefix?: string;
+    refresh?: boolean;
+    className?: string;
+}
+/**
+ * A self-refreshing relative timestamp. Ticks no faster than the unit it shows,
+ * and stops entirely once the value is days old.
+ */
+declare function RelativeTime({ value, prefix, className, refresh, ...rest }: RelativeTimeProps): React.JSX.Element | null;
+
+/**
+ * File intake helpers — generic, no chat vocabulary.
+ * Nothing here touches the DOM event lifecycle: extractors REPORT what they found,
+ * the host decides whether to consume the event.
+ *
+ * Shared by the forms group and the chat kit — promoted to a top-level shared kit
+ * since multiple component groups depend on it.
+ */
+/** The host library's file shape. Use it for every file everywhere. */
+interface Attachment {
+    id: string;
+    name: string;
+    size: number;
+    mime: string;
+    url: string;
+    /** Local preview while uploading. */
+    blobUrl?: string;
+    /** Non-null and < 100 means uploading. */
+    progress?: number | null;
+    thumb?: {
+        url: string;
+    };
+    /** Failed upload. Takes priority over progress. */
+    error?: string;
+    /** Free-text replacement for the size line, e.g. "6 lines · pasted". */
+    meta?: string;
+    /** Present only before upload; strip it before sending. */
+    file?: File;
+}
+interface FileRejection {
+    file: File;
+    reason: "type" | "size";
+    message: string;
+}
+declare function formatBytes(n: number): string;
+declare function extensionOf(name: string): string;
+/** Phosphor icon name for a file: type first, extension second. */
+declare function iconForMime(mime?: string, name?: string): string;
+declare function isImage(mime?: string, name?: string): boolean;
+/** accept-attribute semantics: ".png,image/*,text/plain" */
+declare function acceptMatches(file: File, accept?: string): boolean;
+/** Split a FileList against accept + size. Rejections carry a reason string, never a silent drop. */
+declare function filterFiles(files: FileList | File[], opts?: {
+    accept?: string;
+    maxFileSize?: number;
+}): {
+    accepted: File[];
+    rejected: FileRejection[];
+};
+/** Human name for a synthesised paste file: "Pasted text (380 lines).txt" */
+declare function pastedTextName(text: string): string;
+/**
+ * What a paste is carrying, in one pass. NEVER calls preventDefault — it returns
+ * `source: null` when nothing was produced, so the host can let the event fall
+ * through. That is what makes it reusable in any input.
+ */
+declare function extractClipboardFiles(event: ClipboardEvent, opts?: {
+    largePasteThreshold?: number;
+    accept?: string;
+    maxFileSize?: number;
+    name?: string;
+}): {
+    files: File[];
+    source: "files" | "text" | null;
+    rejected: FileRejection[];
+    text?: string;
+};
+/**
+ * Local, immediately-renderable stand-in for a file being uploaded.
+ * Shape is the host library's file type — id/name/size/mime/url/progress/thumb/error.
+ */
+declare function toAttachment(file: File, extra?: Partial<Attachment>): Attachment;
+declare function revokeAttachment(att: Attachment): void;
+/**
+ * Namespace export — `const { formatBytes } = window.<Namespace>.FileKit;`
+ */
+declare const FileKit: {
+    formatBytes: typeof formatBytes;
+    extensionOf: typeof extensionOf;
+    iconForMime: typeof iconForMime;
+    isImage: typeof isImage;
+    acceptMatches: typeof acceptMatches;
+    filterFiles: typeof filterFiles;
+    pastedTextName: typeof pastedTextName;
+    extractClipboardFiles: typeof extractClipboardFiles;
+    toAttachment: typeof toAttachment;
+    revokeAttachment: typeof revokeAttachment;
+};
+
+declare const meterFormats: {
+    count: (n: number) => string;
+    compact: (n: number) => string;
+    bytes: typeof formatBytes;
+    percentOf: (total: number) => (n: number) => string;
+};
+interface MeterSegmentInput {
+    id?: string;
+    label: string;
+    value: number;
+    variant?: "brand" | "neutral" | "quiet" | "ok" | "warn" | "danger" | "info";
+    /** Any CSS colour; overrides variant. Defaults to the chart ramp in order. */
+    color?: string;
+}
+interface SegmentedMeterProps {
+    total: number;
+    segments: MeterSegmentInput[];
+    label?: string;
+    /** Value formatter. meterFormats.compact | .count | .bytes */
+    format?: (n: number) => string;
+    height?: number;
+    legend?: boolean;
+    showTotal?: boolean;
+    showPercent?: boolean;
+    remainderLabel?: string;
+    onClick?: () => void;
+    className?: string;
+    /** Base id for the meter's aria-labelledby target; falls back to React.useId(). */
+    id?: string;
+}
+/**
+ * A capacity bar split into categories — a context window, a disk quota, a budget
+ * burn-down, a rate limit. Deliberately free of any AI vocabulary: it takes a total
+ * and labelled segments, and reports the remainder as free space.
+ *
+ * A zero or missing total reports 0%, never NaN%.
+ */
+declare function SegmentedMeter({ total, segments, label, format, height, legend, showTotal, showPercent, remainderLabel, onClick, className, id, }: SegmentedMeterProps): React.JSX.Element;
+interface QuotaRowProps {
+    label: React.ReactNode;
+    percent: number;
+    note?: React.ReactNode;
+    tone?: "brand" | "ok" | "warn" | "danger";
+    className?: string;
+}
+/**
+ * One quota line: name, an optional reset note, a percentage and a bar.
+ * Rate limits, plan allowances, storage tiers.
+ */
+declare function QuotaRow({ label, percent, note, tone, className }: QuotaRowProps): React.JSX.Element;
+
+interface SortMenuField {
+    /** Sort key sent to the endpoint. */
+    key: string;
+    /** Human label shown in the menu and on the collapsed trigger. */
+    label: string;
+    /** Numeric fields read "lowest/highest first" instead of "A to Z". */
+    numeric?: boolean;
+}
+interface SortMenuProps extends React.HTMLAttributes<HTMLSpanElement> {
+    fields: SortMenuField[];
+    /** Current sort, straight from the endpoint's response envelope. */
+    sort?: {
+        key: string;
+        dir: "asc" | "desc";
+    } | null;
+    onSort?: (key: string, dir: "asc" | "desc") => void;
+    /** Which edge the popover aligns to. Default "right". */
+    align?: "left" | "right";
+    className?: string;
+}
+/**
+ * SortMenu — the sort control for every server-driven table.
+ *
+ * A raw "sort=crp&dir=desc" readout tells a user what the machine is doing, not what
+ * they asked for. This states the field in words and offers both directions as explicit
+ * targets, so choosing "highest first" is one click rather than a toggle you have to
+ * click twice and then verify.
+ *
+ * Direction wording follows the field type — numeric fields read "lowest/highest first",
+ * text fields "A to Z" — while both use the same arrow pair, because varying the icon by
+ * type encodes a distinction nobody asked for and reads as inconsistency.
+ *
+ * Purely presentational: reports intent through onSort(key, dir) and never holds sort
+ * state, so it stays honest against a real endpoint.
+ */
+declare function SortMenu({ fields, sort, onSort, align, className, ...rest }: SortMenuProps): React.JSX.Element;
+
+interface Step {
+    id: string;
+    /** Short verb + target: "Queried calls table". */
+    label: string;
+    kind?: "tool" | "search" | "read" | "write" | "reasoning" | "run" | "fetch";
+    /** Raw input/output or reasoning text, behind a disclosure. */
+    detail?: string;
+    durationMs?: number;
+    status?: "running" | "ok" | "error";
+}
+/** Flat collapsible rows — never one card per tool call. */
+interface StepListProps {
+    steps: Step[];
+    label?: string;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onToggle?: (open: boolean) => void;
+    showDurations?: boolean;
+    dense?: boolean;
+    className?: string;
+}
+/**
+ * A flat, collapsible list of work steps — one row per step, never one card per
+ * call. A long run stays readable: it is a list, not a stack.
+ */
+declare function StepList({ steps, label, defaultOpen, open: openProp, onToggle, showDurations, dense, className, }: StepListProps): React.JSX.Element | null;
+
+/**
+ * Multi-select control with a 44px comfortable hit area.
+ */
+interface CheckboxProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    /** Renders as a bordered selectable card — for the big, calm choices. */
+    card?: boolean;
+    indeterminate?: boolean;
+}
+declare function Checkbox({ label, description, card, indeterminate, className, ...rest }: CheckboxProps): React.JSX.Element;
+
+/** One-of-many control. Share a name across the group. */
+interface RadioProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    card?: boolean;
+}
+declare function Radio({ label, description, card, className, ...rest }: RadioProps): React.JSX.Element;
+
+/** An immediate on/off setting — no Save button. Use Checkbox inside forms instead. */
+interface SwitchProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+}
+declare function Switch({ label, description, className, ...rest }: SwitchProps): React.JSX.Element;
+
+/**
+ * Labelled text field. 44px tall, 8px radius, hairline border, blue focus ring.
+ */
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "prefix"> {
+    label?: string;
+    help?: string;
+    /** Present = error state. Replaces help text. */
+    error?: string;
+    /** Static text inside the field, left — e.g. "$" */
+    prefix?: React.ReactNode;
+    /** Static text inside the field, right — e.g. "CPM" */
+    suffix?: React.ReactNode;
+    /** Phosphor icon name shown left of the input */
+    icon?: string;
+    /** Right-aligned tabular figures. Use for every money or count field. */
+    numeric?: boolean;
+    required?: boolean;
+    size?: "md" | "lg";
+    /** Inline spinner on the right — for async validation or a value still arriving. */
+    loading?: boolean;
+    /** Applied to the outer .fd-field element — this is where width belongs. */
+    style?: React.CSSProperties;
+    /** Applied to the inner input element. Rarely needed. */
+    inputStyle?: React.CSSProperties;
+}
+declare function Input({ label, help, error, prefix, suffix, icon, numeric, required, size, loading, disabled, id, className, style, inputStyle, ...rest }: InputProps): React.JSX.Element;
+
+/** Multi-line field. Same chrome as Input; vertical resize only. */
+interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+    help?: string;
+    error?: string;
+    required?: boolean;
+    rows?: number;
+    /** Applied to the field wrapper. */
+    style?: React.CSSProperties;
+}
+declare function Textarea({ label, help, error, required, rows, disabled, id, className, style, ...rest }: TextareaProps): React.JSX.Element;
+
+/** Numeric field with thousands formatting on blur, +/- steppers with hold-to-repeat acceleration, arrow keys (shift = bigStep), and min/max clamping. */
+interface NumberInputProps {
+    label?: string;
+    help?: string;
+    error?: string;
+    prefix?: string;
+    suffix?: string;
+    required?: boolean;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Larger step used while holding the steppers or shift+arrows. */
+    bigStep?: number;
+    /** Thousands-format the display when not editing. Default true. */
+    format?: boolean;
+    value?: number | string;
+    /** Called with {target:{value}} where value is a number. */
+    onChange?: (e: any) => void;
+    placeholder?: string;
+    style?: any;
+    className?: string;
+}
+declare function NumberInput({ label, help, error, prefix, suffix, required, disabled, min, max, step, bigStep, value, onChange, format, className, style, placeholder }: NumberInputProps): React.JSX.Element;
+
+/** Rich popover select: animated listbox, keyboard nav + type-ahead, search over 8 options, option icons, descriptions, meta and groups. API-compatible with the old native select. */
+interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    meta?: any;
+    group?: string;
+    disabled?: boolean;
+}
+interface SelectProps {
+    label?: string;
+    help?: string;
+    error?: string;
+    options: Array<string | SelectOption>;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    /** Options still arriving — the control locks and shows a spinner. */
+    loading?: boolean;
+    /** Force the search box on/off; default: on when over 8 options. */
+    searchable?: boolean;
+    /** Show an x that clears back to placeholder. */
+    clearable?: boolean;
+    /** Pick several: `value` is an array, the popover stays open, options get
+     *  checkboxes, and a footer offers Select all / Clear. */
+    multiple?: boolean;
+    /** With `multiple`, override the collapsed box text for 2+ selections. */
+    summary?: (values: string[]) => string;
+    value?: string | string[];
+    /** Called with {target:{value}} like a native select — an array when `multiple`. */
+    onChange?: (e: any) => void;
+    name?: string;
+    /** Applied to the outer .fd-field element — this is where width belongs. */
+    style?: any;
+    className?: string;
+    /** Element id — forwarded to the trigger button and the label's htmlFor. Not present on the original .d.ts but required by the source markup. */
+    id?: string;
+}
+declare function Select({ label, help, error, options, placeholder, required, disabled, loading, value, onChange, searchable, clearable, multiple, summary, id, className, style, ...rest }: SelectProps): React.JSX.Element;
+
+/** Calendar popover date field. Click the title to drill month -> year; range mode picks start then end with live hover preview. Values are ISO strings ("2026-03-01"). */
+interface DatePickerProps {
+    label?: string;
+    help?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    /** false: value is "YYYY-MM-DD". true: value is {start, end}. */
+    range?: boolean;
+    value?: any;
+    /** Called with {target:{value}} — string, or {start,end} in range mode. */
+    onChange?: (e: any) => void;
+    placeholder?: string;
+    style?: any;
+    className?: string;
+}
+/** The bare calendar, for embedding in custom surfaces. months=2 renders two side-by-side months (used by range mode). */
+interface CalendarProps {
+    value?: any;
+    range?: boolean;
+    onPick: (v: any) => void;
+    initialMonth?: string;
+    months?: number;
+}
+declare function Calendar({ value, range, onPick, initialMonth, months }: CalendarProps): React.JSX.Element;
+declare function DatePicker({ label, help, error, required, disabled, range, value, onChange, placeholder, className, style, ...rest }: DatePickerProps): React.JSX.Element;
+
+/** Analog clock-face time field: tap or drag the hand to set the hour, auto-advances to minutes; AM/PM chips; "Now" shortcut. Value is 24h "HH:MM". */
+interface TimePickerProps {
+    label?: string;
+    help?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    /** 24h "HH:MM", e.g. "14:30". */
+    value?: string;
+    /** Called with {target:{value}}. */
+    onChange?: (e: any) => void;
+    placeholder?: string;
+    style?: any;
+    className?: string;
+}
+/** The bare clock face, for embedding (e.g. below a Calendar). */
+interface ClockFaceProps {
+    value?: string;
+    onChange: (v: string) => void;
+}
+declare function ClockFace({ value, onChange }: ClockFaceProps): React.JSX.Element;
+declare function TimePicker({ label, help, error, required, disabled, value, onChange, placeholder, className, style }: TimePickerProps): React.JSX.Element;
+
+/**
+ * Continuous value control. In the media planner this is the reallocation slider:
+ * a live chip follows the handle while dragging and the commit is explicit.
+ */
+interface SliderProps {
+    label?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    onChange?: (value: number) => void;
+    /** Renders the value in the chip and header, e.g. v => "$" + v.toLocaleString() */
+    format?: (value: number) => string;
+    showChip?: boolean;
+    help?: string;
+    className?: string;
+}
+declare function Slider({ label, min, max, step, value, onChange, format, showChip, help, className, ...rest }: SliderProps): React.JSX.Element;
+
+/** Dual-thumb range slider: drag either thumb or the rail, value bubbles while dragging or focused, tick marks with labels, optional magnetic snap, keyboard (arrows, shift for 10%, Home/End). */
+interface RangeSliderProps {
+    label?: string;
+    help?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** [low, high] */
+    value: [number, number];
+    onChange: (v: [number, number]) => void;
+    /** Minimum distance the thumbs keep between them. */
+    minGap?: number;
+    /** Tick stops; label is optional. */
+    marks?: Array<{
+        value: number;
+        label?: string;
+    }>;
+    /** Ordinal mode: unevenly spaced legal values (numbers, or {value,label}); the
+     *  slider then travels in even steps between them and reports real values.
+     *  Infinity is allowed for an open upper bound — give it a label like "No limit". */
+    stops?: Array<number | {
+        value: number;
+        label?: string;
+    }>;
+    /** Magnetically snap to nearby marks while dragging. */
+    snap?: boolean;
+    format?: (v: number) => string;
+    className?: string;
+}
+declare function RangeSlider({ label, min, max, step, value, onChange, minGap, marks, snap, stops, format, help, className, ...rest }: RangeSliderProps & Record<string, any>): JSX.Element;
+
+interface DropzoneProps {
+    onFiles?: (files: File[]) => void;
+    onReject?: (rejections: FileRejection[]) => void;
+    accept?: string;
+    maxFileSize?: number;
+    multiple?: boolean;
+    disabled?: boolean;
+    label?: string;
+    hint?: string;
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * A drop target that wraps any content. Reports accepted files and rejections;
+ * it never uploads anything itself.
+ */
+declare function Dropzone({ onFiles, onReject, accept, maxFileSize, multiple, disabled, label, hint, children, className, style, }: DropzoneProps): React.JSX.Element;
+interface FilePickButtonProps extends Omit<DropzoneProps, "children" | "label" | "hint" | "style"> {
+    label?: string;
+    icon?: string;
+    children?: React.ReactNode;
+}
+/** A file input behind any trigger. Resets between picks so re-picking the same file fires. */
+declare function FilePickButton({ onFiles, onReject, accept, maxFileSize, multiple, disabled, label, icon, className, children, }: FilePickButtonProps): React.JSX.Element;
+type FileUploadHandler = (file: File, onProgress: (pct: number) => void, signal?: AbortSignal) => Promise<{
+    url: string;
+    thumb?: {
+        url: string;
+    };
+} | void>;
+/**
+ * Upload orchestration for a staged set of files: progress per file, per-file
+ * errors, retry, and cancel — the same behaviour an upload field has.
+ *
+ * `upload(file, onProgress, signal)` must resolve to `{url, thumb?}` or throw.
+ * Nothing here knows what a chat is; it is the app's upload handler that does.
+ */
+declare function useStagedFiles(upload?: FileUploadHandler, opts?: {
+    onUploaded?: (a: Attachment) => void;
+    onError?: (e: unknown, a: Attachment) => void;
+}): {
+    items: Attachment[];
+    add: (files: File[] | FileList) => Attachment[];
+    remove: (a: Attachment) => void;
+    retry: (a: Attachment) => void;
+    clear: () => void;
+    busy: boolean;
+    setItems: (items: Attachment[]) => void;
+};
+/** Namespace export — useStagedFiles is a hook, so it cannot be capital-initial itself. */
+declare const DropzoneKit: {
+    useStagedFiles: typeof useStagedFiles;
+};
+
+interface FileChipProps {
+    file: Attachment;
+    onOpen?: (f: Attachment) => void;
+    onRemove?: (f: Attachment) => void;
+    onRetry?: (f: Attachment) => void;
+    compact?: boolean;
+    className?: string;
+}
+/**
+ * A compact file row: icon or thumbnail, name, size, live upload progress,
+ * error state, and an optional remove control. One file component everywhere —
+ * images get real thumbnails, video gets a play badge, uploads get a bar.
+ */
+declare function FileChip({ file, onOpen, onRemove, onRetry, compact, className }: FileChipProps): React.JSX.Element | null;
+interface FileTileProps {
+    file: Attachment;
+    onOpen?: (f: Attachment) => void;
+    onRemove?: (f: Attachment) => void;
+    maxHeight?: number;
+    className?: string;
+}
+/**
+ * An image-forward tile. Pasted screenshots belong here, not in a chip —
+ * the picture is the content.
+ */
+declare function FileTile({ file, onOpen, onRemove, maxHeight, className }: FileTileProps): React.JSX.Element | null;
+/**
+ * One row of uniform tiles — the staging tray. Same size whatever the type:
+ * images crop to fill, documents show a truncated name and their size.
+ * Overflow scrolls sideways instead of growing the tray.
+ */
+interface FileStripProps {
+    files: Attachment[];
+    size?: number;
+    onOpen?: (f: Attachment) => void;
+    onRemove?: (f: Attachment) => void;
+    onRetry?: (f: Attachment) => void;
+    className?: string;
+}
+declare function FileStrip({ files, size, onOpen, onRemove, onRetry, className }: FileStripProps): React.JSX.Element | null;
+/** Images as tiles, everything else as chips. */
+interface FileGridProps {
+    files: Attachment[];
+    onOpen?: (f: Attachment) => void;
+    onRemove?: (f: Attachment) => void;
+    onRetry?: (f: Attachment) => void;
+    tiles?: boolean;
+    maxHeight?: number;
+    compact?: boolean;
+    className?: string;
+}
+/**
+ * A set of files: images as tiles, everything else as chips.
+ * `tiles={false}` forces the compact all-chips form for tight columns.
+ */
+declare function FileGrid({ files, onOpen, onRemove, onRetry, tiles, maxHeight, compact, className }: FileGridProps): React.JSX.Element | null;
+
+interface MarkdownEditorHandle {
+    focus(opts?: FocusOptions): void;
+    blur(): void;
+    readonly element: HTMLElement | null;
+    getSelection(): {
+        start: number;
+        end: number;
+    };
+    replaceRange(start: number, end: number, text: string, caretAt?: number): void;
+    insert(text: string): void;
+    wrapSelection(before: string, after?: string, placeholder?: string): void;
+    prefixLines(prefix: string): void;
+}
+interface EditorTrigger {
+    type: "slash" | "mention";
+    query: string;
+    from: number;
+    to: number;
+}
+/**
+ * Rich markdown composer. A contenteditable whose text content IS the markdown
+ * source, one element per line — so headings can be bigger and bold can be bold
+ * without a mirror to keep in metric lockstep.
+ *
+ * Keydown ordering contract: the host sees the event FIRST (onKeyDown), may call
+ * preventDefault(), and the editor then checks defaultPrevented and skips its own
+ * handling. onPaste follows the same contract.
+ */
+interface MarkdownEditorProps {
+    value: string;
+    onChange?: (next: string) => void;
+    onSubmit?: (value: string) => void;
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    onPaste?: (e: React.ClipboardEvent) => void;
+    onTrigger?: (t: EditorTrigger | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    maxLength?: number;
+    minRows?: number;
+    maxRows?: number;
+    autoFocus?: boolean;
+    /** Enter sends, Shift+Enter inserts a newline. Default true. */
+    submitOnEnter?: boolean;
+    ariaLabel?: string;
+    className?: string;
+    id?: string;
+}
+/**
+ * The composer field.
+ *
+ * Keydown ordering contract — the host sees the event FIRST:
+ *    editor emits onKeyDown  →  host may call preventDefault()
+ *    →  editor checks event.defaultPrevented and skips its own handling
+ * Emitting after the internal handler would make the host's preventDefault
+ * arrive too late. onPaste follows the same contract.
+ */
+declare const MarkdownEditor: React.ForwardRefExoticComponent<MarkdownEditorProps & React.RefAttributes<MarkdownEditorHandle>>;
+
+interface AccountMenuLink {
+    id: string;
+    label: string;
+    icon: string;
+    href?: string;
+    /** Hidden unless the signed-in user holds this permission. */
+    perm?: string;
+    badge?: string;
+    onSelect?: () => void;
+}
+interface AccountMenuProps {
+    links?: AccountMenuLink[];
+    /** Administration section. Each entry is filtered by its own `perm`. */
+    adminLinks?: AccountMenuLink[];
+    /** Preferred over href navigation — lets an SPA route without a page load. */
+    onNavigate?: (href: string | undefined, item: AccountMenuLink) => void;
+    onSignOut?: () => void;
+    showRoles?: boolean;
+    /** Demo affordance: impersonate another member to see their UI. Default true. */
+    allowUserSwitch?: boolean;
+    className?: string;
+}
+/**
+ * The avatar button + popover every flytedesk app puts in its top right.
+ * Reads the signed-in user from SessionKit; shows Administration only to those who can use it.
+ */
+declare function AccountMenu({ links, adminLinks, onNavigate, onSignOut, showRoles, allowUserSwitch, className, ...rest }: AccountMenuProps): React.JSX.Element;
+
+interface EndpointSpec {
+    id: string;
+    method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+    path: string;
+    title: string;
+    purpose: string;
+    usedBy?: string[];
+    /** [lo, hi] ms. Doubles as the latency SLO the UI's loading states are designed around. */
+    latency: [number, number];
+    request?: unknown;
+    query?: unknown;
+    response: unknown;
+    notes?: string;
+    /** Marks a paged list returning the { rows, pager, sort, filter } envelope. */
+    isList?: boolean;
+}
+interface SpecModule {
+    id: string;
+    label: string;
+    icon?: string;
+    endpoints: string[];
+}
+interface ApiSpecBrowserProps {
+    spec?: EndpointSpec[];
+    /** The app's simulated transport: (id, params) => Promise<any>. Powers "Try it". */
+    onRequest: (id: string, params: unknown) => Promise<unknown>;
+    /** Screen → endpoints map. Rendered as the primary filter. */
+    modules?: SpecModule[];
+    /** Lifecycle grouping: [[label, endpointIds]] */
+    groups?: Array<[string, string[]]>;
+    title?: string;
+    kicker?: string;
+    lede?: string;
+    /** Where the spec lives and how to swap in the real transport. */
+    sourceNote?: string;
+    conventions?: Array<[string, string]>;
+    openQuestions?: Array<[string, string, string]>;
+    className?: string;
+}
+declare function Json({ obj }: {
+    obj: unknown;
+}): React.JSX.Element;
+/** Drop-in browser for a simulated API contract. Takes the spec as data. */
+declare function ApiSpecBrowser({ spec, onRequest, modules, groups, title, kicker, lede, sourceNote, conventions, openQuestions, className, ...rest }: ApiSpecBrowserProps): React.JSX.Element;
+
+interface PermissionItem {
+    key: string;
+    label: string;
+    detail: string;
+}
+interface PermissionGroup {
+    group: string;
+    items: PermissionItem[];
+}
+interface Role {
+    id: string;
+    name: string;
+    system: boolean;
+    description: string;
+    permissions: string[];
+}
+interface Flag {
+    key: string;
+    project: string;
+    label: string;
+    description: string;
+    /** Kill switch. False means off for everyone, whatever the targeting says. */
+    enabled: boolean;
+    /** 0-100. Bucketed on a stable hash of the user id so answers never flicker. */
+    rollout: number;
+    /** Role ids the flag is forced on for. */
+    roles: string[];
+    /** Per-user overrides, highest precedence: { userId: true | false } */
+    users: Record<string, boolean>;
+    owner?: string;
+    updated?: string;
+    /** Which screen this flag gates, if any. */
+    screen?: string;
+    /** Target ship date for an unshipped feature. */
+    eta?: string | null;
+    /** Date this shipped — set instead of `eta` once it's done. */
+    shippedAt?: string;
+    /** Build phase index into PHASES. */
+    phase?: number;
+    /** Human estimate, e.g. "4 days". */
+    effort?: string;
+    /** What has to be built for this to be real. */
+    backend?: string;
+    /** Other flag keys this depends on. */
+    dependsOn?: string[];
+}
+interface User {
+    id: string;
+    name: string;
+    email: string;
+    title?: string;
+    team?: string;
+    roles: string[];
+    status: "active" | "invited" | "suspended";
+    lastActive?: string;
+    joined?: string;
+    sso?: boolean;
+    timezone?: string;
+    phone?: string;
+    bio?: string;
+    notify?: Record<string, boolean>;
+}
+interface Session {
+    user: User;
+    roles: Role[];
+    permissions: string[];
+    /** Resolved flag key → on/off for THIS user. */
+    flags: Record<string, boolean>;
+    allRoles: Role[];
+    allFlags: Flag[];
+    allUsers: User[];
+}
+interface FlagExplanation {
+    on: boolean;
+    reason: string;
+    detail: string;
+}
+/** roadmap()'s per-flag result row. Not declared in session.d.ts (roadmap() itself is one of
+ *  the six SessionKit members missing from that file) — inferred from what roadmap() actually
+ *  builds and returns for each flag. */
+interface RoadmapItem {
+    key: string;
+    label: string;
+    project: string;
+    description: string;
+    backend?: string;
+    effort?: string;
+    owner?: string;
+    dependsOn: string[];
+    screen: string | null;
+    enabled: boolean;
+    /** Which build phase this sits in, and why that phase comes where it does. */
+    phase?: number;
+    phaseName: string;
+    phaseWhy: string | null;
+    phaseStart: string | null;
+    /** Derived, not stored: whether every endpoint the feature needs is wired. */
+    implemented: boolean;
+    date: string | null;
+    /** True when the only date on record is when the UI was designed, not when it ships. */
+    dateIsDesign: boolean;
+    status: "shipped" | "next" | "planned";
+}
+/** roadmap()'s return shape. */
+interface RoadmapResult {
+    items: RoadmapItem[];
+    /** Index of the first unshipped item — everything above it is history. */
+    nextIndex: number;
+    shipped: number;
+    remaining: number;
+}
+/** Stable 0–99 bucket from a string, so rollout answers never flicker between reloads. */
+declare function bucket(seed: string): number;
+/** Build the session document a real GET /me would return. */
+declare function buildSession(userId: string, overrides?: {
+    users?: User[];
+    roles?: Role[];
+    flags?: Flag[];
+}): Session;
+/** The precedence rule, in one place so the admin UI and the app can never disagree. */
+declare function evaluateFlag(flag: Flag, user: User): boolean;
+/** Why a flag resolved the way it did — shown in the admin UI, invaluable in support. */
+declare function explainFlag(flag: Flag, user: User): FlagExplanation;
+declare global {
+    interface Window {
+        /** Admin-app-injected overrides for the demo dataset, read by loadSession(). */
+        __FD_ADMIN_OVERRIDES?: {
+            users?: User[];
+            roles?: Role[];
+            flags?: Flag[];
+        };
+    }
+}
+/** Replace this with `fetch(API + "/me")` to go live. */
+declare function loadSession(userId?: string): Session;
+declare function getSession(): Session;
+declare function setActiveUser(userId: string): Session;
+/** Local profile edits persist so the demo keeps them across reloads. */
+declare function saveProfile(patch: Partial<User>): User;
+/** Recompute after the admin app mutates users/roles/flags. */
+declare function refresh(): Session;
+declare function subscribe(fn: (s: Session) => void): () => void;
+declare function can(permission: string | string[]): boolean;
+declare function canAny(permissions: string[]): boolean;
+declare function hasRole(roleId: string): boolean;
+declare function flagOn(key: string): boolean;
+/** The flag registry entry, whatever the session shape.
+ *  Not declared in session.d.ts — see the module doc comment on SessionKit below. */
+declare function findFlag(key: string): Flag | null;
+declare function flagState(key: string): "on" | "off";
+declare function isEnabled(key: string): boolean;
+declare function flagVisible(key: string): boolean;
+declare function flagLive(key: string): boolean;
+declare function roadmap(overrides?: {
+    flags?: Flag[];
+    isComplete?: (key: string) => boolean;
+}): RoadmapResult;
+/** React binding. Re-renders on user switch, profile save, or admin mutation. */
+declare function useSession(): Session;
+/**
+ * Session, RBAC and feature flags for every flytedesk app.
+ *
+ * Not a security boundary: permissions gate the UI so people aren't shown affordances they
+ * cannot use. The server must re-check all of it.
+ *
+ * To go live, replace loadSession() with a fetch of GET /me → { user, roles, permissions, flags }.
+ */
+declare const SessionKit: {
+    PERMISSION_CATALOG: PermissionGroup[];
+    ALL_PERMISSIONS: string[];
+    ROLES: Role[];
+    FLAGS: Flag[];
+    USERS: User[];
+    loadSession: typeof loadSession;
+    getSession: typeof getSession;
+    setActiveUser: typeof setActiveUser;
+    saveProfile: typeof saveProfile;
+    refresh: typeof refresh;
+    subscribe: typeof subscribe;
+    can: typeof can;
+    canAny: typeof canAny;
+    hasRole: typeof hasRole;
+    flagOn: typeof flagOn;
+    useSession: typeof useSession;
+    findFlag: typeof findFlag;
+    flagState: typeof flagState;
+    isEnabled: typeof isEnabled;
+    flagVisible: typeof flagVisible;
+    flagLive: typeof flagLive;
+    roadmap: typeof roadmap;
+    evaluateFlag: typeof evaluateFlag;
+    explainFlag: typeof explainFlag;
+    bucket: typeof bucket;
+    buildSession: typeof buildSession;
+};
+
+interface DeviceSession {
+    id: string;
+    device: string;
+    where: string;
+    when: string;
+    current?: boolean;
+}
+interface ProfilePageProps {
+    /** Defaults to the signed-in user from SessionKit. */
+    user?: User;
+    /** Persist through your own endpoint. Defaults to SessionKit.saveProfile. */
+    onSave?: (draft: Partial<User>) => void | Promise<void>;
+    onNavigate?: (href: string) => void;
+    sessions?: DeviceSession[];
+    showSessions?: boolean;
+    className?: string;
+}
+/**
+ * The shared profile page: identity, working preferences, notifications, devices.
+ * Roles are shown but never editable — self-promotion is the reason RBAC exists.
+ */
+declare function ProfilePage({ user: userProp, onSave, onNavigate, sessions, showSessions, className, ...rest }: ProfilePageProps): React.JSX.Element;
+
+interface RoadmapTimelineProps {
+    /** Called with a flag key when the reader clicks one — route it to your flag admin. */
+    onOpenFlag?: (flagKey: string) => void;
+    /** Heading. Default "Roadmap". */
+    title?: string;
+    /** Replaces the default explanation of what the timeline covers. */
+    lede?: string;
+}
+/**
+ * A vertical, chronological map of what is wired to the real backend and what is next.
+ *
+ * Derived entirely from the feature-flag registry (`SessionKit.roadmap()`) — status is each
+ * flag's `implemented` field, ordering comes from its date, and blocking relationships come
+ * from its `dependsOn`. Nothing here is maintained separately, so it cannot drift from what
+ * the apps actually do.
+ *
+ * Shipped work sits above a "you are here" marker and upcoming work below it; the scroll
+ * container opens at that marker, so the first thing in view is what comes next.
+ */
+declare function RoadmapTimeline({ onOpenFlag, title, lede }: RoadmapTimelineProps): React.JSX.Element;
+
+interface PermissionDeniedProps {
+    permission?: string | string[];
+    title?: string;
+    detail?: string;
+    compact?: boolean;
+    className?: string;
+}
+/** Explains a block rather than hiding it — silence reads as a bug and files a ticket. */
+declare function PermissionDenied({ permission, title, detail, compact, className, ...rest }: PermissionDeniedProps): React.JSX.Element;
+interface GateProps {
+    /** All of these must be held. */
+    perm?: string | string[];
+    /** At least one of these must be held. */
+    anyOf?: string[];
+    role?: string | string[];
+    /** Render nothing instead of an explanation — for chrome like toolbar buttons. */
+    silent?: boolean;
+    fallback?: React.ReactNode;
+    compact?: boolean;
+    children?: React.ReactNode;
+}
+/** Permission gate. Denied by default shows PermissionDenied. */
+declare function Gate({ perm, anyOf, role, silent, fallback, compact, children }: GateProps): React.ReactNode;
+interface FeatureGateProps {
+    flag: string;
+    fallback?: React.ReactNode;
+    children?: React.ReactNode;
+    /** Renders a "See the roadmap" link inside the ComingSoon banner when supplied. */
+    onRoadmap?: () => void;
+    /** Blur radius in px for the underlying, inert UI. Passed through to ComingSoon. */
+    blur?: number;
+    minHeight?: number | string;
+    /** Overrides the ComingSoon banner headline. Defaults to the flag's own label (or a generic one). */
+    label?: string;
+    /** "block" wraps a panel; "inline" wraps a single control (button, chip, menu item). Default "block". */
+    variant?: "block" | "inline";
+    /** When false, an incomplete-in-live-mode feature renders `fallback` instead of the ComingSoon banner. Default true. */
+    preview?: boolean;
+    /** Permission that lets the viewer bypass the ComingSoon veil and use the feature early. Default "flags.manage". */
+    bypassPerm?: string;
+}
+/** Feature gate. ALWAYS silent when off — an unreleased feature should leave no trace. */
+declare function FeatureGate({ flag, fallback, children, onRoadmap, blur, minHeight, label, variant, preview, bypassPerm }: FeatureGateProps): React.ReactNode;
+/** Inline "why is this disabled" affordance for buttons that must stay visible. */
+declare function PermissionHint({ perm, children }: {
+    perm: string | string[];
+    children?: React.ReactNode;
+}): React.ReactNode;
+
+interface ComingSoonProps {
+    /** Banner headline. Default "Coming soon". */
+    label?: string;
+    /** Target date, already formatted for display. */
+    eta?: string | null;
+    /** Rough size of the remaining work, e.g. "3 weeks". */
+    effort?: string;
+    /** What has to be built on the server for this to go live. */
+    backend?: string | null;
+    /** One line describing the feature itself. */
+    detail?: string;
+    /** Blur radius in px. Default 3 — enough to stop reading, not enough to hide the shape. */
+    blur?: number;
+    minHeight?: number | string;
+    /** "block" wraps a panel; "inline" wraps a single control (button, chip, menu item). */
+    variant?: "block" | "inline";
+    /** Renders a "See the roadmap" link when supplied. */
+    onRoadmap?: () => void;
+    /**
+     * Flag key identifying this feature. Supply it together with `canBypass` to offer a
+     * "View and use it anyway" escape — the choice is remembered for the session (sessionStorage,
+     * not localStorage: a bypass that survives days becomes the silent default).
+     */
+    bypassKey?: string;
+    /**
+     * Whether this viewer may unblur. Gate on a permission the people building the feature hold
+     * (`flags.manage`). While bypassed the feature is fully interactive, with a persistent,
+     * non-dismissible bar stating that writes go to the simulated backend.
+     */
+    canBypass?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+/**
+ * A feature that is designed and working but not yet wired to the real backend: the real UI,
+ * blurred, behind a construction banner, and fully inert (`pointer-events`, the `inert`
+ * attribute, and `aria-hidden`). Lets people see what is coming without acting on it.
+ *
+ * Usually reached through `FeatureGate`, which resolves the flag state for you. Use this
+ * directly only when the gating decision is already made elsewhere.
+ */
+declare function ComingSoon({ label, eta, effort, backend, detail, blur, minHeight, 
+/** "block" wraps a panel; "inline" wraps a single control (button, chip, menu item). */
+variant, onRoadmap, 
+/** Flag key. Supplying it AND `canBypass` lets the viewer unblur and use the feature. */
+bypassKey, canBypass, children, className, ...rest }: ComingSoonProps): JSX.Element;
+declare function formatEta(iso?: string | null): string | null;
+declare const FormatEta: typeof formatEta;
+
+interface ModeSwitchProps {
+    /** Render nothing unless true. Pass SessionKit.can("flags.manage"). */
+    canToggle?: boolean;
+    /** Simulated requests this session — shown as a count badge in test mode. */
+    requestCount?: number;
+    onClearLog?: () => void;
+    /** Request-log body, rendered inside the popover in test mode only. */
+    renderLog?: () => React.ReactNode;
+    onOpenSpec?: () => void;
+    summary?: {
+        total: number;
+        complete: number;
+        incomplete: number;
+        endpointsWired: number;
+    };
+}
+/** Header control: lightning in live mode, flask + request count in test mode. */
+declare function ModeSwitch({ canToggle, requestCount, onClearLog, renderLog, onOpenSpec, summary }: ModeSwitchProps): React.ReactNode;
+interface TestModeBarProps {
+    onExit?: () => void;
+}
+/** Persistent strip shown only in test mode. Render at the top of the app frame. */
+declare function TestModeBar({ onExit }: TestModeBarProps): React.ReactNode;
+
+/**
+ * The canonical channel taxonomy. One icon and one hue per medium, used
+ * everywhere a channel is named — table cells, charts, legends, filters, the
+ * client view. The colour is part of the label, not decoration.
+ *
+ * Hue families: blues = large format, violets = moving, ambers = paper,
+ * roses = direct, slate = digital.
+ *
+ * `physical` is a descriptive family property, NOT a weight. The model spec
+ * (v2026-07-21 §4) assigns each channel its own weight from four factor scores —
+ * 23 to 50, with persistence separating the tiers. Read weights from
+ * window.CHANNEL_WEIGHT / MODEL.weights, never from this flag.
+ */
+declare const CHANNEL_WEIGHTS: Record<string, number>;
+/** Spec §4 weight for a channel name, resolving §9 aliases. 0 = unmodeled (contributes no CRP). */
+declare function channelWeightOf(channel: string): number;
+declare const ChannelWeightOf: typeof channelWeightOf;
+interface ChannelMetaRecord {
+    label: string;
+    /** Phosphor icon name, without the `ph-` prefix. */
+    icon: string;
+    /** CSS custom-property reference, e.g. "var(--ch-ooh)". */
+    color: string;
+    /** Hue family: Large format | Moving | Paper | Direct | Digital | Other. */
+    family: string;
+    /** Descriptive family property, not a weight. Channel weights live in MODEL.weights (spec §4). */
+    physical: boolean;
+    name?: string;
+}
+/**
+ * The canonical channel taxonomy — one icon and one hue per medium. Every screen
+ * that names a channel reads from this, so a colour always means the same thing.
+ */
+declare const CHANNELS: Record<string, ChannelMetaRecord>;
+/** Resolve any channel spelling (exact, lowercase key, partial) to its record. */
+declare function ChannelMeta(name?: string | null): ChannelMetaRecord;
+interface ChannelTagProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Channel name — "OOH", "Website (CPM)", "transit"… */
+    channel?: string | null;
+    size?: "sm" | "md";
+    /** Hide the text and show icon only (dense tables). */
+    showLabel?: boolean;
+    /** Render as a bare colour swatch, for chart legends. */
+    dot?: boolean;
+    /** Append the channel's spec §4 weight after the label. */
+    weight?: boolean;
+    className?: string;
+}
+/**
+ * The standard way to render a channel name. Icon + hue + label, in a tinted
+ * chip. Use `dot` for a bare colour swatch in dense legends.
+ */
+declare function ChannelTag({ channel, size, showLabel, dot, weight, className, ...rest }: ChannelTagProps): React.JSX.Element;
+
+/**
+ * The plan's shape: how funded campuses spread across the four CSI bands.
+ * Each campus is one labelled block stacked in its band's column, so the
+ * distribution reads as a silhouette before any number is parsed. Columns are
+ * clickable to filter the school mix by band.
+ */
+interface SaturationDistributionCampus {
+    name: string;
+    /** Short label shown inside the block, e.g. "Michigan State" */
+    short?: string;
+    band: "weak" | "adequate" | "strong" | "dominant";
+    crp?: number;
+}
+interface SaturationDistributionProps {
+    campuses: SaturationDistributionCampus[];
+    /** Band of the plan-level floor score. Renders the floor explainer strip. */
+    floorBand?: "weak" | "adequate" | "strong" | "dominant";
+    /** The plan floor figure, e.g. 157.2 */
+    floorScore?: number | string;
+    onSelectBand?: (band: string | null) => void;
+    selectedBand?: string | null;
+    loading?: boolean;
+    className?: string;
+}
+declare function SaturationDistribution({ campuses, floorBand, floorScore, onSelectBand, selectedBand, loading, className }: SaturationDistributionProps): React.JSX.Element;
+
+/**
+ * Realized media mix against the strategic target, one row per channel.
+ * Realized is a solid brand bar, target a neutral tick on the same row, and the
+ * gap is labelled directly on the bar — the gap is the story, so it never hides
+ * in a legend.
+ */
+interface MixGapRow {
+    channel: string;
+    /** Target share, percent */
+    target: number;
+    /** Realized share, percent */
+    realized: number;
+    /** Why the gap exists, e.g. "Limited inventory at target campuses" — shown in the hover tooltip. */
+    note?: string;
+}
+interface MixGapProps {
+    rows: MixGapRow[];
+    loading?: boolean;
+    className?: string;
+}
+declare function MixGap({ rows, loading, className }: MixGapProps): React.JSX.Element;
+
+/**
+ * How one campus's CRP was built, channel by channel, with the surround-sound
+ * bonus as its own hatched segment. This is the most valuable visualization in
+ * the planner: it answers why a campus scores what it scores and where the
+ * headroom is.
+ */
+interface ChannelContributionChannel {
+    name: string;
+    /** CRP contributed by this channel */
+    crp: number;
+    /** Formatted spend, e.g. "$12,400" */
+    spend?: string;
+    /** Physical formats (OOH, transit, posters) carry roughly 2x the weight of feed-based digital. */
+    physical?: boolean;
+    color?: string;
+}
+interface ChannelContributionProps {
+    channels: ChannelContributionChannel[];
+    /** Surround-sound bonus actually earned, as a percent of the channel base. */
+    bonusPct?: number;
+    /** The model's ceiling. Defaults to 40. */
+    bonusMax?: number;
+    /** Override the computed total when the engine's figure differs from base + bonus. */
+    total?: number;
+    loading?: boolean;
+    showTable?: boolean;
+    className?: string;
+}
+declare function ChannelContribution({ channels, bonusPct, bonusMax, total, loading, showTable, className }: ChannelContributionProps): React.JSX.Element;
+
+/**
+ * The planner's signature interaction: move budget at one campus and watch its
+ * saturation band re-score live. The previewed band renders at 70% opacity with
+ * a dashed edge until the change is committed; Escape reverts.
+ */
+interface BudgetReallocatorProps {
+    campus: string;
+    /** Committed spend. */
+    spend: number;
+    /** Committed CRP. */
+    crp: number;
+    min?: number;
+    max: number;
+    /** Defaults to 100 — the same increment as an arrow-key step. */
+    step?: number;
+    /** The engine's re-score for a candidate spend. Required for a live preview. */
+    scoreFor?: (spend: number) => number;
+    onPreview?: (spend: number, crp: number) => void;
+    onCommit?: (spend: number, crp: number) => void;
+    onCancel?: () => void;
+    className?: string;
+}
+declare function BudgetReallocator({ campus, spend, crp, min, max, step, scoreFor, onPreview, onCommit, onCancel, className }: BudgetReallocatorProps): React.JSX.Element;
+
+/**
+ * Channel-diversity breadth at one campus and the bonus it earned or forgave.
+ * The engine rewards reaching a campus through multiple reinforcing categories
+ * with up to +40% on its score; thin-breadth campuses forgo most of it.
+ */
+interface SurroundSoundProps {
+    /** Category keys present: "ooh" | "transit" | "posters" | "print" | "email" | "web" */
+    present: string[];
+    /** Bonus actually earned, in points of percent. */
+    bonusPct?: number;
+    /** Model ceiling. Defaults to 40. */
+    bonusMax?: number;
+    /** One sentence naming what the missed breadth costs, e.g. "+$3,000 into OOH earns +12%." */
+    missedCost?: string;
+    className?: string;
+}
+declare function SurroundSound({ present, bonusPct, bonusMax, missedCost, className }: SurroundSoundProps): React.JSX.Element;
+
+/**
+ * Chat state machine. Framework-shaped as a React hook, but the rules it encodes
+ * are the portable part: thread resolution, serial sending, escalation polling,
+ * recovery, abort semantics and retry truncation.
+ *
+ * It ships no HTTP client. Without an adapter it resolves nothing and renders
+ * nothing — every app's proxy differs in auth, routing and host.
+ */
+/** Tri-state `valid`: only an explicit false blocks Apply. */
+interface Citation {
+    id?: string;
+    marker?: string | number;
+    title?: string;
+    url?: string;
+    detail?: string;
+}
+/** Tri-state `valid`: only an explicit false blocks Apply. */
+interface Packet {
+    type: string;
+    payload: unknown;
+    valid?: boolean;
+    error?: string;
+    repaired?: boolean;
+}
+interface PacketSchema {
+    heading?: string;
+    icon?: string;
+    applyLabel?: string;
+}
+interface JobStatus {
+    id?: string;
+    /** queued | running keep polling · completed | recovered are success · anything else fails loudly. */
+    status: string;
+    detail?: string;
+    error?: string;
+}
+interface ChatMessage {
+    id: string;
+    role: "user" | "assistant" | "system";
+    text?: string | null;
+    packet?: Packet | null;
+    /** Escalation in flight. */
+    working?: boolean;
+    /** Tokens arriving — renders a live caret. */
+    streaming?: boolean;
+    /** Optimistic, not yet confirmed. */
+    pending?: boolean;
+    /** The turn was stopped by the user. */
+    stopped?: boolean;
+    jobId?: string;
+    job?: JobStatus;
+    error?: string;
+    retryable?: boolean;
+    timestamp?: string;
+    author?: string;
+    steps?: Step[];
+    citations?: Citation[];
+    attachments?: Attachment[];
+    thinking?: string;
+    thinkingMs?: number;
+    feedback?: "up" | "down" | null;
+    model?: string;
+    usage?: unknown;
+    resumed?: boolean;
+    metadata?: {
+        type?: string;
+        [k: string]: unknown;
+    };
+}
+interface SendMessageResult {
+    /** true = escalated to a background job. */
+    dispatched?: boolean;
+    job_id?: string;
+    reply?: string | null;
+    packet?: Packet;
+    steps?: Step[];
+    citations?: Citation[];
+    usage?: unknown;
+    model?: string;
+}
+interface StreamHandlers {
+    /** Chunks APPEND, never replace. */
+    onToken(chunk: string): void;
+    onStep?(step: Step): void;
+    onThinking?(chunk: string): void;
+}
+/**
+ * The app-supplied backend. There is no default: every proxy differs in auth,
+ * routing and host. Reject with the backend's stable error code as the message —
+ * the panel matches codes by exact equality, never substring sniffing.
+ */
+interface ChatAdapter {
+    resolveThread(ctx: {
+        contextType: string;
+        contextId: string;
+    }): Promise<{
+        thread_id: string | null;
+    }>;
+    getThread(threadId: string): Promise<{
+        messages: ChatMessage[];
+    }>;
+    sendMessage(threadId: string, text: string, signal?: AbortSignal, attachments?: Attachment[]): Promise<SendMessageResult>;
+    getJob(jobId: string): Promise<JobStatus>;
+    /** Preferred when present. */
+    streamMessage?(threadId: string, text: string, handlers: StreamHandlers, signal: AbortSignal, attachments?: Attachment[]): Promise<SendMessageResult>;
+    /** Cancels upstream only. It must not gate whether Stop appears. */
+    cancelJob?(jobId: string): Promise<void>;
+}
+interface ChatEngineOptions {
+    contextType: string;
+    contextId: string;
+    apiAdapter?: ChatAdapter | null;
+    initialMessage?: string | null;
+    threadId?: string | null;
+    pollIntervalMs?: number;
+    pollMaxAttempts?: number;
+    store?: {
+        get(k: string): string | null;
+        set(k: string, v: string): void;
+        del(k: string): void;
+    };
+    onPacket?: (p: Packet) => void;
+    onThreadReady?: (id: string) => void;
+    onError?: (e: unknown) => void;
+    onSend?: (text: string) => void;
+    onClear?: () => void;
+    onFeedback?: (x: {
+        message?: ChatMessage;
+        feedback?: string | null;
+    }) => void;
+}
+interface QueuedTurn {
+    id: string;
+    text: string;
+    attachments?: Attachment[];
+}
+interface ChatEngine {
+    status: "idle" | "resolving" | "loading" | "ready" | "disconnected";
+    threadId: string | null;
+    messages: ChatMessage[];
+    visible: ChatMessage[];
+    queue: QueuedTurn[];
+    busy: boolean;
+    fatal: string | null;
+    turnStartedAt: number | null;
+    send(text: string, attachments?: Attachment[]): void;
+    stop(): void;
+    retry(): void;
+    clear(): void;
+    removeQueued(id: string): void;
+    setFeedback(id: string, value: "up" | "down"): void;
+    reload(): Promise<void>;
+    canSend: boolean;
+}
+declare const CHAT_UNAVAILABLE = "chat_unavailable";
+declare const isSystemMessage: (m: ChatMessage | null | undefined) => boolean;
+declare const visibleMessages: (list: ChatMessage[] | null | undefined) => ChatMessage[];
+declare function jobBucket(status?: string): "pending" | "success" | "failure";
+declare function useChatEngine(opts: ChatEngineOptions): ChatEngine;
+/**
+ * Namespace export. The bundle exposes only capital-initial names, so this is how a
+ * consuming project reaches the state machine to build its own shell:
+ *
+ *   const { useChatEngine } = window.<Namespace>.ChatKit;
+ *   const chat = useChatEngine({ contextType, contextId, apiAdapter });
+ */
+declare const ChatKit: {
+    useChatEngine: typeof useChatEngine;
+    visibleMessages: (list: ChatMessage[] | null | undefined) => ChatMessage[];
+    isSystemMessage: (m: ChatMessage | null | undefined) => boolean;
+    jobBucket: typeof jobBucket;
+    CHAT_UNAVAILABLE: string;
+};
+
+interface Suggestion {
+    id?: string;
+    label: string;
+    text?: string;
+    description?: string;
+    icon?: string;
+}
+interface SlashCommand {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    shortcut?: string; /** Send immediately on pick. */
+    immediate?: boolean;
+    run?: () => void;
+}
+interface MentionSource {
+    id?: string;
+    label: string;
+    value?: string;
+    description?: string;
+    icon?: string;
+    meta?: React.ReactNode;
+}
+interface Model {
+    id: string;
+    label: string;
+    description?: string; /** Key HINT only. */
+    shortcut?: string;
+    group?: string;
+    meta?: React.ReactNode;
+    disabled?: boolean;
+}
+interface ContextUsage {
+    total: number;
+    segments: MeterSegmentInput[];
+    label?: string;
+    format?: "count" | "compact" | "bytes";
+}
+interface UsageLimit {
+    id: string;
+    label: string;
+    percent: number;
+    resetsAt?: string;
+    note?: string;
+}
+interface SessionStats {
+    elapsedMs?: number;
+    tokens?: number;
+    runningTasks?: number;
+    costUsd?: number;
+    turns?: number;
+}
+interface ThreadSummary {
+    id: string;
+    title?: string;
+    description?: string;
+    updatedAt?: string;
+}
+type VoiceHandler = (controls: {
+    onText: (text: string, meta?: {
+        replace?: boolean;
+    }) => void;
+    onEnd?: () => void;
+}) => (() => void) | void;
+interface AgentChatPanelProps {
+    contextType: string;
+    contextId: string;
+    apiAdapter: ChatAdapter | null;
+    /** Show this exact thread instead of resolving one from context. Set it from
+     *  onNewThread / onSelectThread to make history switching work. */
+    threadId?: string | null;
+    title?: string;
+    subtitle?: React.ReactNode;
+    showHeader?: boolean;
+    headerActions?: React.ReactNode;
+    onClose?: () => void;
+    assistantName?: string;
+    userName?: string;
+    assistantAvatar?: string;
+    userAvatar?: string;
+    /** Phosphor name for the assistant mark. Default "sparkle". */
+    assistantIcon?: string;
+    showAvatars?: boolean;
+    markdown?: boolean;
+    /** Clamp threshold before Show more. Default 600; 0 disables. */
+    maxVisibleChars?: number;
+    messageActions?: boolean;
+    showSteps?: boolean;
+    showThinking?: boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    emptyIcon?: string;
+    suggestions?: Array<Suggestion | string>;
+    renderEmpty?: () => React.ReactNode;
+    packetSchemas?: Record<string, PacketSchema>;
+    packetRenderers?: Record<string, (p: Packet) => React.ReactNode>;
+    onApplyPacket?: (p: Packet) => void;
+    onOpenAttachment?: (a: Attachment) => void;
+    /** Map a backend error code to human copy. */
+    errorCopy?: (code: string) => React.ReactNode;
+    placeholder?: string;
+    maxLength?: number;
+    hint?: React.ReactNode;
+    /** Omit and there is no attach affordance — a pasted image falls through. */
+    fileUploadHandler?: FileUploadHandler;
+    acceptFiles?: string;
+    maxFileSize?: number;
+    /** Chars above which a paste becomes a .txt attachment. Default 4000. */
+    largePasteThreshold?: number;
+    slashCommands?: SlashCommand[];
+    mentionSources?: MentionSource[] | ((query: string) => Promise<MentionSource[]>);
+    voiceHandler?: VoiceHandler;
+    initialMessage?: string | null;
+    contextUsage?: ContextUsage;
+    sessionStats?: SessionStats;
+    usageLimits?: UsageLimit[];
+    models?: Model[];
+    moreModels?: Model[];
+    model?: string;
+    onModelChange?: (id: string) => void;
+    effortLevels?: string[];
+    effort?: string;
+    onEffortChange?: (level: string) => void;
+    fastMode?: boolean;
+    onFastModeChange?: (on: boolean) => void;
+    threads?: ThreadSummary[];
+    onSelectThread?: (t: ThreadSummary) => void;
+    onNewThread?: () => void;
+    /** Supply to put a delete affordance on each history row. Omit and none renders. */
+    onDeleteThread?: (t: ThreadSummary) => void;
+    surface?: "sidebar" | "inline" | "page" | "modal" | "sheet";
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    resizable?: boolean;
+    height?: number | string;
+    className?: string;
+    style?: React.CSSProperties;
+    onPacket?: (p: Packet) => void;
+    onThreadReady?: (id: string) => void;
+    onError?: (e: unknown) => void;
+    onSend?: (text: string) => void;
+    onClear?: () => void;
+    onFeedback?: (x: {
+        message?: ChatMessage;
+        feedback?: string | null;
+    }) => void;
+    onEditMessage?: (m: ChatMessage) => void;
+}
+/**
+ * Agent chat panel.
+ *
+ * Ships no backend: without `apiAdapter` it loads nothing and says so. Every
+ * optional surface — usage meters, model picker, attachments, avatars, steps —
+ * renders only when its input is supplied. A panel with no telemetry shows no
+ * telemetry, not zeroes.
+ */
+declare function AgentChatPanel({ contextType, contextId, apiAdapter, threadId, title, subtitle, showHeader, headerActions, onClose, assistantName, userName, assistantAvatar, userAvatar, assistantIcon, showAvatars, markdown, maxVisibleChars, messageActions, showSteps, showThinking, emptyTitle, emptyDescription, emptyIcon, suggestions, renderEmpty, packetSchemas, packetRenderers, onApplyPacket, onOpenAttachment, errorCopy, placeholder, maxLength, hint, fileUploadHandler, acceptFiles, maxFileSize, largePasteThreshold, slashCommands, mentionSources, voiceHandler, initialMessage, contextUsage, sessionStats, usageLimits, models, model, onModelChange, effortLevels, effort, onEffortChange, fastMode, onFastModeChange, moreModels, threads, onSelectThread, onNewThread, onDeleteThread, surface, width, minWidth, maxWidth, resizable, height, className, style, onPacket, onThreadReady, onError, onSend, onClear, onFeedback, onEditMessage, }: AgentChatPanelProps): React.JSX.Element;
+
+/**
+ * Staged files, the queue strip, the markdown editor, slash/mention triggers, send + stop.
+ * Enter sends, Shift+Enter continues the list or quote you are in, IME composition never
+ * sends. Omit `fileUploadHandler` and there is no attach affordance at all — a pasted
+ * image then falls through to the editor rather than stranding on a message that cannot
+ * carry it.
+ */
+interface ChatComposerProps {
+    onSubmit: (text: string, attachments?: Attachment[]) => void;
+    /** Offered whenever a turn is in flight, even with no upstream cancel. */
+    onStop?: () => void;
+    busy?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    maxLength?: number;
+    fileUploadHandler?: FileUploadHandler;
+    acceptFiles?: string;
+    maxFileSize?: number;
+    /** Chars above which a paste becomes a .txt attachment. Default 4000. */
+    largePasteThreshold?: number;
+    slashCommands?: SlashCommand[];
+    mentionSources?: MentionSource[] | ((query: string) => Promise<MentionSource[]>);
+    voiceHandler?: VoiceHandler;
+    /** Messages waiting behind the turn in flight. Each row is removable. */
+    queue?: Array<{
+        id: string;
+        text: string;
+        attachments?: Attachment[];
+    }>;
+    onRemoveQueued?: (id: string) => void;
+    /** Rendered above the field — where AgentChatPanel puts the session bar. */
+    sessionBar?: React.ReactNode;
+    toolbarExtras?: React.ReactNode;
+    /** Controlled draft, so a host can prefill (edit-a-message does this). */
+    draft?: string;
+    onDraftChange?: (text: string) => void;
+    hint?: React.ReactNode;
+    narrow?: boolean;
+    autoFocus?: boolean;
+    onReject?: (rejections: FileRejection[]) => void;
+    onOpenAttachment?: (a: Attachment) => void;
+}
+/**
+ * The composer: staged attachments, the visible send queue, the editor, and the
+ * send/stop control. Every optional affordance appears only when its input is
+ * supplied — no upload handler means no attach button at all.
+ */
+declare function ChatComposer({ onSubmit, onStop, busy, disabled, placeholder, maxLength, fileUploadHandler, acceptFiles, maxFileSize, largePasteThreshold, slashCommands, mentionSources, voiceHandler, queue, onRemoveQueued, sessionBar, toolbarExtras, draft, onDraftChange, hint, narrow, autoFocus, onReject, onOpenAttachment, }: ChatComposerProps): React.JSX.Element;
+
+/**
+ * Elapsed time, token spend, context window and quota rows. Renders `null` unless at
+ * least one input is supplied — the bar is never an empty frame.
+ */
+interface ChatSessionBarProps {
+    sessionStats?: SessionStats;
+    contextUsage?: ContextUsage;
+    usageLimits?: UsageLimit[];
+    onClear?: () => void;
+    extras?: React.ReactNode;
+}
+/**
+ * The strip above the composer. Every part is prop-fed: supply none of
+ * sessionStats / contextUsage / usageLimits and no bar renders at all.
+ */
+declare function ChatSessionBar({ sessionStats, contextUsage, usageLimits, onClear, extras }: ChatSessionBarProps): React.JSX.Element | null;
+/**
+ * Model picker, effort level and fast mode. `null` when no models are given.
+ * A model's `shortcut` renders a key cap and binds nothing.
+ */
+interface ModelControlsProps {
+    models?: Model[];
+    model?: string;
+    onModelChange?: (id: string) => void;
+    effortLevels?: string[];
+    effort?: string;
+    onEffortChange?: (level: string) => void;
+    fastMode?: boolean;
+    onFastModeChange?: (on: boolean) => void;
+    fastModeLabel?: string;
+    /** Collapsed into a submenu. */
+    moreModels?: Model[];
+    narrow?: boolean;
+}
+/**
+ * Model picker (+ optional effort and fast-mode). Renders only when `models` is
+ * supplied. Shortcuts are hints; the app registers the real keys.
+ */
+declare function ModelControls({ models, model, onModelChange, effortLevels, effort, onEffortChange, fastMode, onFastModeChange, fastModeLabel, moreModels, narrow: _narrow, }: ModelControlsProps): React.JSX.Element | null;
+
+/**
+ * Render context, built once by AgentChatPanel and threaded into every part.
+ * Assembling your own shell means supplying this yourself.
+ */
+interface ChatRenderContext {
+    assistantName?: string;
+    userName?: string;
+    assistantAvatar?: string;
+    userAvatar?: string;
+    /** Phosphor name for the assistant mark. Default "sparkle". */
+    assistantIcon?: string;
+    showAvatars?: boolean;
+    markdown?: boolean;
+    /** Clamp threshold before Show more. 0 disables. */
+    maxVisibleChars?: number;
+    messageActions?: boolean;
+    showSteps?: boolean;
+    showThinking?: boolean;
+    packetSchemas?: Record<string, PacketSchema>;
+    packetRenderers?: Record<string, (p: Packet) => React.ReactNode>;
+    appliedPackets?: Record<string, boolean>;
+    /** Sidebar-width layout: tighter padding, stacked controls. */
+    narrow?: boolean;
+    onOpenAttachment?: (a: Attachment) => void;
+    /** Max height (px) of the attachment grid before it scrolls. Default 220. */
+    attachmentHeight?: number;
+    /** Renderer for `[^n]` citation markers inside markdown bodies. */
+    renderCitation?: (marker: string) => React.ReactNode;
+    /** Map a backend error code to human copy. */
+    errorCopy?: (code: string) => React.ReactNode;
+    onRetry?: () => void;
+    onFeedback?: (id: string, value: "up" | "down") => void;
+    onEdit?: (m: ChatMessage) => void;
+    onApplyPacket?: (p: Packet) => void;
+    onOpenCitation?: (c: Citation, e: React.MouseEvent) => void;
+    extraActions?: (group: MessageGroup) => React.ReactNode;
+    /** Disconnected-state heading. Default "The assistant isn't reachable". */
+    deadTitle?: string;
+    onReconnect?: () => void;
+}
+/** A run of consecutive messages from one sender — see groupMessages. */
+interface MessageGroup {
+    role: string;
+    author?: string;
+    messages: ChatMessage[];
+    /** A single-message run; affects spacing and the author label. */
+    solo: boolean;
+    key: string;
+}
+/** A structured result. `valid: false` blocks Apply; undefined does not. */
+interface PacketCardProps {
+    packet: Packet;
+    schema?: PacketSchema;
+    render?: (p: Packet) => React.ReactNode;
+    onApply?: (p: Packet) => void;
+    applied?: boolean;
+}
+/**
+ * A structured result carried by a message. `valid` is tri-state: only an
+ * explicit `false` blocks Apply — an unvalidated packet is a legitimate result.
+ */
+declare function PacketCard({ packet, schema, render, onApply, applied }: PacketCardProps): React.JSX.Element | null;
+interface ThinkingBlockProps {
+    text?: string;
+    durationMs?: number;
+    streaming?: boolean;
+    defaultOpen?: boolean;
+}
+declare function ThinkingBlock({ text, durationMs, streaming, defaultOpen }: ThinkingBlockProps): React.JSX.Element | null;
+interface CitationsProps {
+    items?: Citation[];
+    onOpen?: (c: Citation, e: React.MouseEvent) => void;
+}
+declare function Citations({ items, onOpen }: CitationsProps): React.JSX.Element | null;
+/** Message content only — markdown, code blocks, clamping. No chrome. */
+interface MessageBodyProps {
+    message: ChatMessage;
+    ctx: ChatRenderContext;
+}
+declare function MessageBody({ message: m, ctx }: MessageBodyProps): React.JSX.Element;
+/** Copy / retry / feedback / edit. Real buttons; the hover reveal is CSS only. */
+interface RunActionsProps {
+    group: MessageGroup;
+    ctx: ChatRenderContext;
+}
+/**
+ * One toolbar per run — copying the whole run, not one message. Buttons stay in
+ * the DOM (the reveal is CSS only), so keyboard and screen-reader users, who
+ * never produce a hover, can still reach them.
+ */
+declare function RunActions({ group, ctx }: RunActionsProps): React.JSX.Element | null;
+/** One turn: author label, body, attachments, packet, thinking, citations, actions. */
+interface ChatTurnProps {
+    group: MessageGroup;
+    ctx: ChatRenderContext;
+}
+declare function ChatTurn({ group, ctx }: ChatTurnProps): React.JSX.Element;
+
+/** Consecutive messages from one sender inside 60s share a head. Anything
+ *  carrying a packet, steps or an error always starts its own group. */
+declare function groupMessages(list: ChatMessage[]): MessageGroup[];
+/**
+ * Runs of consecutive messages from one sender, for run-vs-turn spacing.
+ * `role="log"` and deliberately NOT also aria-live — a live region on a
+ * transcript makes a screen reader announce every token of a streaming reply.
+ */
+interface ChatTranscriptProps {
+    messages?: ChatMessage[];
+    ctx: ChatRenderContext;
+    status?: "idle" | "resolving" | "loading" | "ready" | "disconnected";
+    /** Terminal error code; renders the disconnected state. */
+    fatal?: string | null;
+    suggestions?: Array<Suggestion | string>;
+    onPick?: (s: Suggestion | string) => void;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    emptyIcon?: string;
+    renderEmpty?: () => React.ReactNode;
+    className?: string;
+}
+/**
+ * The transcript: a role="log" region (and deliberately not aria-live too —
+ * that doubles announcements). Grouping, day dividers, and an auto-scroll that
+ * follows only while the reader is already at the bottom.
+ */
+declare function ChatTranscript({ messages, ctx, status, fatal, suggestions, onPick, emptyTitle, emptyDescription, emptyIcon, renderEmpty, className, }: ChatTranscriptProps): React.JSX.Element;
+/** Namespace export — grouping helper, for consumers rendering their own transcript. */
+declare const TranscriptKit: {
+    groupMessages: typeof groupMessages;
+};
+
+interface TableQuery {
+    /** 1-indexed. */
+    page: number;
+    pageSize: number;
+    sort: string | null;
+    dir: "asc" | "desc";
+    /** Free-text search across the endpoint's searchable columns. */
+    q: string;
+    filters: Record<string, unknown>;
+}
+interface Pager {
+    page: number;
+    pageSize: number;
+    total: number;
+    totalPages: number;
+    from: number;
+    to: number;
+    hasPrev: boolean;
+    hasNext: boolean;
+}
+/** The envelope EVERY paged list endpoint returns. */
+interface ListEnvelope<Row = unknown> {
+    rows: Row[];
+    pager: Pager;
+    sort: {
+        key: string;
+        dir: "asc" | "desc";
+    } | null;
+    filter: {
+        applied: Record<string, unknown>;
+        q: string;
+        facets: Record<string, Record<string, number>>;
+    };
+    aggregate?: Record<string, unknown>;
+}
+interface RunConfig<Row = unknown> {
+    searchKeys?: string[];
+    filters?: Record<string, (row: Row, value: any) => boolean>;
+    /** Sort value for a column whose key isn't a plain field. */
+    accessors?: Record<string, (row: Row) => unknown>;
+    /** Option counts, computed over the SEARCHED set so a filter never erases its own alternatives. */
+    facets?: Record<string, (row: Row) => string | number | null>;
+    defaultSort?: {
+        key: string;
+        dir: "asc" | "desc";
+    };
+    defaultPageSize?: number;
+}
+interface ServerTable<Row = unknown> {
+    rows: Row[];
+    pager: Pager;
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    from: number;
+    to: number;
+    facets: Record<string, Record<string, number>>;
+    aggregate: Record<string, unknown>;
+    query: TableQuery;
+    sort?: {
+        key: string;
+        dir: "asc" | "desc";
+    };
+    q: string;
+    filters: Record<string, unknown>;
+    loading: boolean;
+    /** True only on the FIRST load — later loads keep showing stale rows. */
+    initialLoading: boolean;
+    /** True while re-querying with previous rows still on screen. Pass straight to
+     *  DataTable's `refreshing`, or to LoadingRegion as state="refreshing". */
+    refreshing: boolean;
+    activeFilterCount: number;
+    setPage(p: number): void;
+    setPageSize(n: number): void;
+    setQ(q: string): void;
+    toggleSort(key: string): void;
+    setSortKey(key: string, dir?: "asc" | "desc"): void;
+    /** Same query, unpaged — for CSV export and select-all-matching. */
+    fetchAll(): Promise<Row[]>;
+    /** value may be an updater fn — REQUIRED for toggles, or two fast clicks read the same
+     *  stale array and the first is lost. */
+    setFilter(id: string, value: unknown | ((prev: unknown) => unknown)): void;
+    clearFilter(id: string): void;
+    setFilters(filters: Record<string, unknown>): void;
+    clearFilters(): void;
+    refresh(): void;
+    queryString: string;
+}
+interface UseServerTableOptions {
+    endpoint: string;
+    params?: Record<string, unknown>;
+    defaults?: Partial<TableQuery>;
+    /** Extra values that should trigger a refetch. */
+    deps?: unknown[];
+    /** Opts into durable rows-per-page and default sort. Page/search/filters are deliberately
+     *  NOT persisted — they describe one task, and restoring them hides rows the user expects. */
+    prefsKey?: string;
+}
+declare function eqFilter<Row>(get: (row: Row) => unknown): (row: Row, value: unknown) => boolean;
+declare function anyOfFilter<Row>(get: (row: Row) => string[]): (row: Row, value: unknown) => boolean;
+declare function rangeFilter<Row>(get: (row: Row) => number): (row: Row, value: unknown) => boolean;
+type Api = {
+    request(id: string, params?: unknown): Promise<unknown>;
+};
+type PrefsStore = {
+    getTable(key: string): any;
+    setTable(key: string, patch: any): void;
+};
+declare global {
+    interface Window {
+        PlannerPrefs?: PrefsStore;
+    }
+}
+/** React hook — the only way a screen should talk to a list endpoint. */
+declare function useServerTable<Row = unknown>({ endpoint, params, defaults, deps, prefsKey }: UseServerTableOptions): ServerTable<Row>;
+declare const QueryKit: {
+    DEFAULTS: TableQuery;
+    /** Register the app's simulated (or real) transport: an object with .request(id, params). */
+    setApi<T extends Api>(api: T): T;
+    getApi(): Api;
+    /** Optional durable table preferences store: { getTable(key), setTable(key, patch) }. */
+    setPrefs(p: PrefsStore): void;
+    /**
+     * @param rows  the full static dataset (stands in for the table)
+     * @param query { page, pageSize, sort, dir, q, filters }
+     * @param cfg   { searchKeys[], filters: {id: (row, value) => boolean},
+     *                accessors: {colKey: (row) => sortableValue},
+     *                facets: {id: (row) => facetValue} }
+     */
+    run<Row>(rows: Row[], query: Partial<TableQuery>, cfg: RunConfig<Row>): ListEnvelope<Row>;
+    /** Display form of a query, for the request log and the API spec screen. */
+    toQueryString(query: Partial<TableQuery>): string;
+    useServerTable: typeof useServerTable;
+};
+
+/** Runtime mode and computed feature completeness. */
+interface FeatureStatus {
+    /** Every endpoint this feature needs is served by the real backend. */
+    complete: boolean;
+    /** Endpoint ids still unserved. */
+    missing: string[];
+    /** No requirements were declared — treated as incomplete (fails closed). */
+    undeclared?: boolean;
+    /** Needs no backend at all. */
+    clientOnly?: boolean;
+}
+interface RuntimeSummary {
+    total: number;
+    complete: number;
+    incomplete: number;
+    endpointsWired: number;
+}
+declare const RuntimeKit: {
+    WIRED_ENDPOINTS: string[];
+    CLIENT_ONLY: string[];
+    FEATURE_NEEDS: Record<string, string[]>;
+    /** Register what each feature needs: { "planner.flights": ["flights.list", "flights.shift"] } */
+    declare(map: Record<string, string[]>): void;
+    needsOf(key: string): string[];
+    /** Every declared feature, for the admin surface. */
+    declared(): string[];
+    isEndpointWired(id: string): boolean;
+    /** The whole point: complete is computed, never stored. */
+    status(key: string): FeatureStatus;
+    isComplete(key: string): boolean;
+    getMode(): "live" | "test";
+    isTest(): boolean;
+    setMode(next: "live" | "test"): void;
+    subscribe(fn: (mode: "live" | "test") => void): () => void;
+    /** Counts for the admin surface and the mode popover. */
+    summary(): RuntimeSummary;
+};
+declare function useRuntimeMode(): "live" | "test";
+/** True when this feature should be shown obstructed right now. */
+declare function useFeatureStatus(key: string): FeatureStatus & {
+    mode: "live" | "test";
+    obstruct: boolean;
+};
+declare const UseRuntimeMode: typeof useRuntimeMode;
+declare const UseFeatureStatus: typeof useFeatureStatus;
+
+interface MockJobStatus<TResult = unknown> {
+    id: string;
+    status: "queued" | "running" | "done" | "failed";
+    progress?: number;
+    stage?: string;
+    result?: TResult;
+    /** Set only when status is "failed" — the thrown value's message. */
+    error?: string;
+}
+interface PollOptions<TResult = unknown> {
+    /** Delay between polls, ms. Default 400 — the rate every hand-written poller used. */
+    intervalMs?: number;
+    onTick?: (status: MockJobStatus<TResult>) => void;
+}
+/**
+ * @param prefix   id prefix, e.g. "imp" → "imp_1a2b3c"
+ * @param latency  [lo, hi] ms — total time across every stage, jittered within the range
+ * @param stages   progress labels in order, e.g. ["Uploading", "Parsing", "Validating"]
+ * @param compute  runs once, on the final stage, to produce the result — or throws to fail the job
+ */
+declare function schedule<TResult>(prefix: string, latency: [number, number], stages: string[], compute: () => TResult): string;
+/** Plain status lookup — what a jobs.get-style mock endpoint wraps. Throws if the id is unknown. */
+declare function get<TResult = unknown>(jobId: string): MockJobStatus<TResult>;
+/** Polls until the job resolves. Resolves with the result on "done", throws on "failed". */
+declare function poll<TResult = unknown>(jobId: string, opts?: PollOptions<TResult>): Promise<TResult>;
+declare const MockJobKit: {
+    schedule: typeof schedule;
+    get: typeof get;
+    poll: typeof poll;
+};
+
+/** One entry in the append-only history. Never mutated after it's appended,
+ *  except for `current` flipping to false when a later version is committed. */
+interface VersionRecord<TDiff = unknown> {
+    v: number;
+    current: boolean;
+    who: string;
+    when: string;
+    action: string;
+    /** Human-readable change descriptions, as returned by the mutator passed to commit(). */
+    changes: string[];
+    /** Present only when the store was created with a `diff` option. */
+    diff?: TDiff;
+    /** Open bag for caller-specific before/after figures (e.g. a computed total) that
+     *  don't belong in `diff` because they aren't part of the state comparison itself. */
+    meta?: Record<string, unknown>;
+}
+interface CreateVersionStoreOptions<TState, TDiff = unknown> {
+    /** Defaults to structuredClone. Override if TState holds something it can't clone
+     *  (a class instance, a function) — must still produce a deep, independent copy. */
+    clone?: (state: TState) => TState;
+    /** Computes what a version's `diff` field holds by comparing the state before and
+     *  after the mutation. Omit if the caller has no use for a structured diff — the
+     *  `changes` string list on every record still describes what happened. */
+    diff?: (before: TState, after: TState) => TDiff;
+    /** Timestamp/attribution stamp for `when`. Defaults to `new Date().toISOString()`. */
+    now?: () => string;
+    /** Version number the initial state is recorded under. Defaults to 0. */
+    initialVersion?: number;
+    who?: string;
+    action?: string;
+}
+interface VersionStore<TState, TDiff = unknown> {
+    /** The live state. Mutating it directly bypasses versioning — always go through commit(). */
+    getState(): TState;
+    /** Newest first, matching the order a version-history panel reads top to bottom. */
+    getVersions(): VersionRecord<TDiff>[];
+    getVersion(v: number): VersionRecord<TDiff> | undefined;
+    /**
+     * Snapshots the state before mutation, runs `mutate` against the live state, then
+     * appends a new version recording what changed and keeps a full-state snapshot of
+     * the result so this version can be restored to or undone past later.
+     */
+    commit(who: string, action: string, mutate: (state: TState) => string[], meta?: Record<string, unknown>): VersionRecord<TDiff>;
+    /** Makes version `v` current by committing its snapshot as a NEW head version —
+     *  history is append-only, so this never rewrites or truncates the list. */
+    restoreTo(v: number, who?: string): VersionRecord<TDiff>;
+    /** Restores the state one version behind the current head, committed as a new head
+     *  version (the inverse of the head's change, recorded rather than erased). Throws
+     *  if the head is already the oldest recorded version. */
+    undo(who?: string): VersionRecord<TDiff>;
+}
+declare function createVersionStore<TState, TDiff = unknown>(initialState: TState, options?: CreateVersionStoreOptions<TState, TDiff>): VersionStore<TState, TDiff>;
+
+export { AccountMenu, type AccountMenuLink, type AccountMenuProps, AgentChatPanel, type AgentChatPanelProps, ApiSpecBrowser, type ApiSpecBrowserProps, type Attachment, Avatar, type AvatarProps, AvatarStack, type AvatarStackProps, Badge, type BadgeProps, BudgetReallocator, type BudgetReallocatorProps, Button, type ButtonProps, CHANNELS, CHANNEL_WEIGHTS, CHAT_UNAVAILABLE, Calendar, type CalendarProps, Card, type CardProps, CardRow, type CardRowProps, ChannelContribution, type ChannelContributionChannel, type ChannelContributionProps, ChannelMeta, type ChannelMetaRecord, ChannelTag, type ChannelTagProps, ChannelWeightOf, type ChatAdapter, ChatComposer, type ChatComposerProps, type ChatEngine, type ChatEngineOptions, ChatKit, type ChatMessage, type ChatRenderContext, ChatSessionBar, type ChatSessionBarProps, ChatTranscript, type ChatTranscriptProps, ChatTurn, type ChatTurnProps, Checkbox, type CheckboxProps, type Citation, Citations, type CitationsProps, Clamp, type ClampProps, ClockFace, type ClockFaceProps, CodeBlock, type CodeBlockProps, Collapsible, type CollapsibleProps, ComingSoon, type ComingSoonProps, type ContextUsage, type CreateVersionStoreOptions, CsiBadge, type CsiBadgeProps, CsiHero, type CsiHeroProps, CsiMeter, type CsiMeterProps, DataTable, type DataTableColumn, type DataTableProps, DatePicker, type DatePickerProps, type DeviceSession, DiffBlock, type DiffBlockProps, Drawer, type DrawerProps, Dropzone, DropzoneKit, type DropzoneProps, type EditorTrigger, EmptyState, type EmptyStateProps, type EndpointSpec, FeatureGate, type FeatureGateProps, type FeatureStatus, FileChip, type FileChipProps, FileGrid, type FileGridProps, FileKit, FilePickButton, type FilePickButtonProps, type FileRejection, FileStrip, type FileStripProps, FileTile, type FileTileProps, type FileUploadHandler, Flag$1 as Flag, type FlagExplanation, type FlagProps, FormatEta, Gate, type GateProps, IconButton, type IconButtonProps, Input, type InputProps, type JobStatus, Json, KeyHint, type KeyHintProps, type ListEnvelope, LoadingRegion, type LoadingRegionProps, Markdown, MarkdownEditor, type MarkdownEditorHandle, type MarkdownEditorProps, MarkdownInline, type MarkdownProps, type MentionSource, Menu, MenuButton, type MenuButtonProps, type MenuItem, type MenuProps, MessageBody, type MessageBodyProps, type MessageGroup, Meter, type MeterProps, type MeterSegment, type MeterSegmentInput, MixGap, type MixGapProps, type MixGapRow, MockJobKit, type MockJobStatus, Modal, type ModalProps, ModeSwitch, type ModeSwitchProps, type Model, ModelControls, type ModelControlsProps, NumberInput, type NumberInputProps, type Packet, PacketCard, type PacketCardProps, type PacketSchema, type Pager, Pagination, type PaginationProps, PermissionDenied, type PermissionDeniedProps, type PermissionGroup, PermissionHint, type PermissionItem, type Placement, type PollOptions, Popover, type PopoverProps, ProfilePage, type ProfilePageProps, ProgressBar, type ProgressBarProps, QueryKit, type QueuedTurn, QuotaRow, type QuotaRowProps, Radio, type RadioProps, RangeSlider, type RangeSliderProps, RelativeTime, type RelativeTimeProps, type RoadmapItem, type RoadmapResult, RoadmapTimeline, type RoadmapTimelineProps, type Role, RunActions, type RunActionsProps, type RunConfig, RuntimeKit, type RuntimeSummary, SaturationDistribution, type SaturationDistributionCampus, type SaturationDistributionProps, SegmentedControl, type SegmentedControlProps, SegmentedMeter, type SegmentedMeterProps, Select, type SelectOption, type SelectProps, type SendMessageResult, type ServerTable, type Session, type Flag as SessionFlag, SessionKit, type SessionStats, SidebarNav, type SidebarNavItem, type SidebarNavProps, Skeleton, type SkeletonProps, SkeletonText, type SkeletonTextProps, type SlashCommand, Slider, type SliderProps, SortMenu, type SortMenuField, type SortMenuProps, type SpecModule, Spinner, type SpinnerProps, StatTile, type StatTileProps, type Step, StepList, type StepListProps, type StreamHandlers, type Suggestion, SurroundSound, type SurroundSoundProps, Switch, type SwitchProps, type TableQuery, Tabs, type TabsProps, Tag, type TagProps, TestModeBar, type TestModeBarProps, Textarea, type TextareaProps, ThinkingBlock, type ThinkingBlockProps, type ThreadSummary, TimePicker, type TimePickerProps, Toast, type ToastProps, Tooltip, type TooltipProps, Topbar, type TopbarProps, TranscriptKit, type UsageLimit, UseFeatureStatus, UseRuntimeMode, type UseServerTableOptions, type User, type VersionRecord, type VersionStore, type VoiceHandler, acceptMatches, anyOfFilter, channelWeightOf, createVersionStore, eqFilter, extensionOf, extractClipboardFiles, filterFiles, formatAbsolute, formatBytes, formatClock, formatDuration, formatEta, formatRelative, groupMessages, hasModifier, iconForMime, isImage, isSystemMessage, jobBucket, languageLabel, markdownToText, meterFormats, modifierLabel, pastedTextName, rangeFilter, revokeAttachment, toAttachment, tokenize, useChatEngine, useFeatureStatus, usePopoverPosition, useRuntimeMode, useServerTable, useStagedFiles, visibleMessages };