@neuronection/assistant-ui 0.28.1 → 0.29.1

package/dist/index.d.ts

@@ -1,99 +1,76 @@
 import { ClassValue } from 'clsx';
 export { ClassValue } from 'clsx';
-export { RawTokenName, SemanticTokenName, ThemeTokenName, ThemeTokens, rawTokens, semanticTokens } from './tokens.js';
-export { FileCard, FileCardProps, FileCardStatus, formatBytes } from './file-card.js';
-export { FileQueue, FileQueueItem, FileQueueProps } from './file-queue.js';
-export { Portal, PortalProps } from './portal.js';
+import { ThemeTokens } from './tokens.js';
+export { RawTokenName, SemanticTokenName, ThemeTokenName, rawTokens, semanticTokens } from './tokens.js';
 import * as React from 'react';
-export { ThemeScope, ThemeScopeProps } from './theme-scope.js';
-export { L as LogoProps, a as LogoTheme, u as useLogoId } from './Logo-D8DEBUoL.js';
-export { CareerMark, HealthMark, NeuronectionMark, NeuronectionWordmark, NeuronectionWordmarkProps, StudyMark } from './logo.js';
-export { AboutCard, AboutCardProps, AboutCreator, AboutFooterLine, AboutFooterLineProps, AboutLicense, AboutLinkItem, AboutLinkList, AboutLinkListProps, AboutNote, AboutNoteContent, AboutNoteProps, AboutPanel, AboutPanelProps, AboutSponsorContent, FamilyApp, FamilyBadge, FamilyBadgeProps, FamilyCreator, FamilyMember, SponsorCard, SponsorCardProps, SponsorChannel, TechChips, TechChipsProps } from './about.js';
-export { AiAction, AiActionsDropdown, AiActionsDropdownProps } from './ai-actions-dropdown.js';
-export { AiButton, AiButtonProps } from './ai-button.js';
-export { AiMagicFill, AiMagicFillProps } from './ai-magic-fill.js';
-export { FlowError, FlowStatusCard, FlowStatusCardProps, FlowStep, FlowStepStatus } from './flow-status.js';
-export { Badge, BadgeProps, badgeVariants } from './badge.js';
-export { BreadcrumbItem, BreadcrumbLinkProps, Breadcrumbs, BreadcrumbsProps } from './breadcrumbs.js';
-export { Button, ButtonProps, buttonVariants } from './button.js';
-export { ConnectionTestRow, ConnectionTestRowProps, ConnectionTestStatus } from './connection-test-row.js';
-export { ProviderForm, ProviderFormProps } from './provider-form.js';
-export { SettingsNavItem, SettingsShell, SettingsShellProps } from './settings-shell.js';
-export { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from './card.js';
-export { CheckIndicator, CheckIndicatorProps } from './check-indicator.js';
-export { ChipInput, ChipInputProps } from './chip-input.js';
-export { ChipList, ChipListProps, ChipVariant } from './chip-list.js';
-export { Combobox, ComboboxMulti, ComboboxMultiProps, ComboboxOption, ComboboxProps } from './combobox.js';
-export { ConfirmationModal, ConfirmationModalProps } from './confirmation-modal.js';
-export { CopyButton, CopyButtonProps } from './copy-button.js';
-export { ContextMenu, ContextMenuItem, ContextMenuProps } from './context-menu.js';
-export { DatePicker, DatePickerProps } from './date-picker.js';
-export { EmptyState, EmptyStateProps } from './empty-state.js';
-export { ErrorBanner, ErrorBannerProps } from './error-banner.js';
-export { ExpandableSearch, ExpandableSearchProps } from './expandable-search.js';
-export { FieldLabel, FieldLabelProps } from './field-label.js';
-export { FormModal, FormModalProps } from './form-modal.js';
-export { InfoButton, InfoButtonProps } from './info-button.js';
-export { Input, InputProps } from './input.js';
-export { MarqueeBand, MarqueePhase, MarqueeSelection, MarqueeSurface, MarqueeSurfaceProps, Rect, UseMarqueeOptions, hitTestIds, marqueeRect, rectsIntersect, useMarquee } from './marquee.js';
-export { ActionMenu, ActionMenuItem, ActionMenuProps, Menu, MenuCheckboxItem, MenuCheckboxItemProps, MenuContent, MenuGroup, MenuItem, MenuItemProps, MenuLabel, MenuSeparator, MenuTrigger } from './menu.js';
-export { UserMenu, UserMenuItem, UserMenuProps } from './user-menu.js';
-export { Modal, ModalClose, ModalContent, ModalContentProps, ModalDescription, ModalFooter, ModalHeader, ModalTitle, ModalTrigger, PanelModal, PanelModalProps, modalContentVariants } from './modal.js';
-export { Popover, PopoverAnchor, PopoverClose, PopoverContent, PopoverTrigger } from './popover.js';
-export { PopoverButton, PopoverButtonProps } from './popover-button.js';
-export { RangeBar, RangeBarProps } from './range-bar.js';
-export { ScaleSlider, ScaleSliderProps, scaleColorForValue } from './scale-slider.js';
-export { SearchInput, SearchInputProps } from './search-input.js';
-export { ModelPicker, ModelPickerModel, ModelPickerProps, ModelPickerProvider } from './model-picker.js';
-export { CapabilityChips, CapabilityChipsProps, CapabilityDescriptor } from './capability-chips.js';
-export { ModelRegistry, ModelRegistryDraft, ModelRegistryModel, ModelRegistryPatch, ModelRegistryProps, ModelRegistryProvider, ModelRegistryRemoteModel, ModelRegistryRemoteState } from './model-registry.js';
-export { SelectionBar, SelectionBarProps } from './selection-bar.js';
-export { NavChild, NavItem, SidebarNav, SidebarNavLabels, SidebarNavProps } from './sidebar-nav.js';
-export { Spinner, SpinnerProps } from './spinner.js';
-export { TaskAssignmentPicker, TaskAssignmentPickerProps, TaskAssignmentSection, TaskAssignmentTask } from './task-assignment-picker.js';
-export { Table, TableProps } from './table.js';
-export { InfoTooltip, InfoTooltipProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from './tooltip.js';
-export { TimeList, TimeListProps } from './time-list.js';
-export { TimePicker, TimePickerContent, TimePickerContentProps, TimePickerProps } from './time-picker.js';
-export { UndoNotice, UndoNoticeProps } from './undo-notice.js';
-export { ViewToggle, ViewToggleProps, ViewToggleView } from './view-toggle.js';
-export { Stepper, StepperProps, StepperStep, Wizard, WizardContext, WizardProps, WizardStep } from './wizard.js';
-export { RichTextEditor, RichTextEditorIcons, RichTextEditorLabels, RichTextEditorProps, RichTextToolbarGroup } from './rich-text-editor.js';
-export { DictationButton, DictationButtonProps, DictationError, DictationResult, DictationStatus, DictationStrip, DictationStripLabels, DictationStripProps, UseDictationOptions, useDictation } from './dictation.js';
-export { AiTextTransformEventHandlers, AiTextTransformStatus, AiTextTransformTransport, UseAiTextTransformOptions, useAiTextTransform } from './ai-text-transform.js';
-export { DiffCell, DiffRow, DiffSegment, LineDiffOptions, LineDiffResult, TextDiffView, TextDiffViewLabels, TextDiffViewProps, computeLineDiff, wordSegments } from './text-diff-view.js';
-export { a as ChatAttachmentView, b as ChatError, c as ChatMessageStatus, d as ChatMessageVariants, e as ChatMessageView, C as ChatRole } from './types-DZwzmyKE.js';
-export { ChatStreamEvent, ChatStreamTransport, FlowStepInfo, LiveNodeState, LiveToolCall, LiveTurnAction, LiveTurnState, LiveTurnStatus, UseChatStreamOptions, UseChatStreamResult, initialLiveTurnState, liveTurnReducer, useChatStream } from './chat-core.js';
-export { B as BranchNode, a as BranchNodeInput, b as BranchTree, c as activePathSet, d as buildBranchTree, l as linearTree, v as variantInfo, w as walkActivePath } from './tree-YaIz73vo.js';
-export { MarkdownCodeBlock, MarkdownCodeBlockLabels, MarkdownCodeBlockProps, MarkdownComponents, MarkdownSurface, MarkdownSurfaceProps, MermaidDiagram, MermaidDiagramProps } from './chat-markdown.js';
-export { ChatMessage, ChatMessageAction, ChatMessageActions, ChatMessageEditor, ChatMessageEditorLabels, ChatMessageEditorProps, ChatMessageLabels, ChatMessageProps, MessageVariantSwitcher, MessageVariantSwitcherLabels, MessageVariantSwitcherProps } from './chat-message.js';
-export { ChatReasoning, ChatReasoningLabels, ChatReasoningProps } from './chat-reasoning.js';
-export { ChatToolCard, ChatToolCardLabels, ChatToolCardProps } from './chat-tool-card.js';
-export { ChatTurnStatus, ChatTurnStatusLabels, ChatTurnStatusProps } from './chat-turn-status.js';
-export { ChatComposer, ChatComposerIcons, ChatComposerLabels, ChatComposerProps } from './chat-composer.js';
-export { ChatTranscript, ChatTranscriptLabels, ChatTranscriptProps } from './chat-transcript.js';
-export { ChatBranchTree, ChatBranchTreeIcons, ChatBranchTreeLabels, ChatBranchTreeNode, ChatBranchTreeProps } from './chat-branch-tree.js';
-export { ChatSessionList, ChatSessionListIcons, ChatSessionListLabels, ChatSessionListProps, ChatSessionView } from './chat-session-list.js';
-export { ChatToolCatalogArgument, ChatToolCatalogEntry, ChatToolsCatalog, ChatToolsCatalogLabels, ChatToolsCatalogProps } from './chat-tools-catalog.js';
-export { ChatExportMessage, ChatExportOptions, buildChatMarkdown, chatExportFileName, downloadChatMarkdown } from './chat-export.js';
-export { ChatHistoryButton, ChatHistoryButtonLabels, ChatHistoryButtonProps } from './chat-history-button.js';
-export { ChatTraceMeta, ChatTraceMetaProps } from './chat-trace-meta.js';
-export { ChatTraceTimeline, ChatTraceTimelineEntry, ChatTraceTimelineLabels, ChatTraceTimelineProps, ChatTraceTimelineTrace } from './chat-trace-timeline.js';
-export { ChatPanel, ChatPanelProps, ChatPanelVariant } from './chat-panel.js';
-export { ChatDrawer, ChatDrawerProps } from './chat-drawer.js';
-export { ChatLauncher, ChatLauncherProps } from './chat-launcher.js';
-import 'class-variance-authority/types';
-import 'class-variance-authority';
-import 'lucide-react';
-import '@radix-ui/react-dropdown-menu';
-import '@radix-ui/react-dialog';
-import '@radix-ui/react-popover';
-import '@radix-ui/react-tooltip';
-import '@tiptap/react';
-import 'react-markdown';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { LucideIcon } from 'lucide-react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { Editor, Extensions } from '@tiptap/react';
+import { Components, UrlTransform } from 'react-markdown';
 
 declare function cn(...inputs: ClassValue[]): string;
 
+type FileCardStatus = 'queued' | 'processing' | 'done' | 'failed';
+declare function formatBytes(bytes: number): string;
+interface FileCardProps {
+    name: string;
+    sizeBytes?: number;
+    status?: FileCardStatus;
+    error?: string | null;
+    /** Small preview URL (app owns object-URL lifecycle). */
+    thumbnailUrl?: string | null;
+    included?: boolean;
+    onToggleInclude?: () => void;
+    onRemove?: () => void;
+    onOpen?: () => void;
+    draggable?: boolean;
+    onDragStart?: () => void;
+    onDragEnd?: () => void;
+    removeLabel?: string;
+    includeLabel?: string;
+    className?: string;
+}
+declare const FileCard: React.ForwardRefExoticComponent<FileCardProps & React.RefAttributes<HTMLDivElement>>;
+
+interface FileQueueItem {
+    id: string;
+    name: string;
+    sizeBytes?: number;
+    status?: FileCardStatus;
+    error?: string | null;
+    thumbnailUrl?: string | null;
+    included?: boolean;
+}
+interface FileQueueProps {
+    files: FileQueueItem[];
+    onRemove?: (id: string) => void;
+    onToggleInclude?: (id: string) => void;
+    onOpen?: (id: string) => void;
+    onReorder?: (fromId: string, toId: string) => void;
+    reorderable?: boolean;
+    emptyText?: string;
+    summary?: React.ReactNode;
+    removeLabel?: string;
+    includeLabel?: string;
+    className?: string;
+}
+/**
+ * FileCard grid with aggregate summary and optional drag-to-reorder
+ * (reports intent via `onReorder(fromId, toId)` — the app owns ordering).
+ */
+declare const FileQueue: React.ForwardRefExoticComponent<FileQueueProps & React.RefAttributes<HTMLDivElement>>;
+
+interface PortalProps {
+    children: React.ReactNode;
+    container?: HTMLElement | null;
+}
+declare function Portal({ children, container }: PortalProps): React.ReactPortal | null;
+
 interface UploadDropzoneProps {
     onFiles: (files: File[]) => void;
     uploading?: boolean;
@@ -115,4 +92,2462 @@ interface UploadDropzoneProps {
  */
 declare const UploadDropzone: React.ForwardRefExoticComponent<UploadDropzoneProps & React.RefAttributes<HTMLDivElement>>;
 
-export { UploadDropzone, type UploadDropzoneProps, cn };
+interface ThemeScopeProps extends React.ComponentProps<'div'> {
+    tokens?: ThemeTokens;
+}
+declare const ThemeScope: React.ForwardRefExoticComponent<Omit<ThemeScopeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+type LogoTheme = 'light' | 'dark';
+interface LogoProps extends Omit<React.ComponentProps<'svg'>, 'children'> {
+    size?: number | string;
+    theme?: LogoTheme;
+    title?: string;
+}
+declare const useLogoId: () => string;
+
+declare const NeuronectionMark: React.ForwardRefExoticComponent<Omit<LogoProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+
+interface NeuronectionWordmarkProps extends LogoProps {
+    mono?: boolean;
+}
+declare const NeuronectionWordmark: React.ForwardRefExoticComponent<Omit<NeuronectionWordmarkProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+
+declare const CareerMark: React.ForwardRefExoticComponent<Omit<LogoProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+
+declare const StudyMark: React.ForwardRefExoticComponent<Omit<LogoProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+
+declare const HealthMark: React.ForwardRefExoticComponent<Omit<LogoProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+
+interface AboutCardProps extends Omit<React.ComponentProps<'div'>, 'title'> {
+    icon?: React.ReactNode;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    heading?: 'h2' | 'h3' | 'h4';
+}
+declare const AboutCard: React.ForwardRefExoticComponent<Omit<AboutCardProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface AboutLinkItem {
+    href?: string;
+    label: React.ReactNode;
+    subtitle?: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    external?: boolean;
+    group?: React.ReactNode;
+    copyValue?: string;
+    copyLabel?: string;
+    copiedLabel?: string;
+}
+interface AboutLinkListProps extends React.ComponentProps<'ul'> {
+    links: ReadonlyArray<AboutLinkItem>;
+}
+declare const AboutLinkList: React.ForwardRefExoticComponent<Omit<AboutLinkListProps, "ref"> & React.RefAttributes<HTMLUListElement>>;
+
+declare const noteStyles: (props?: ({
+    tone?: "info" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AboutNoteProps extends Omit<React.ComponentProps<'div'>, 'title'>, VariantProps<typeof noteStyles> {
+    title?: React.ReactNode;
+}
+declare const AboutNote: React.ForwardRefExoticComponent<Omit<AboutNoteProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface AboutFooterLineProps extends React.ComponentProps<'p'> {
+    version?: string;
+    copyright?: React.ReactNode;
+}
+declare const AboutFooterLine: React.ForwardRefExoticComponent<Omit<AboutFooterLineProps, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+
+type FamilyApp = 'health' | 'career' | 'study';
+interface FamilyMember {
+    app: FamilyApp;
+    name: string;
+    tagline?: string;
+    href?: string;
+    github?: string;
+    website?: string;
+}
+interface FamilyCreator {
+    name: React.ReactNode;
+    role?: React.ReactNode;
+    href?: string;
+}
+interface FamilyBadgeProps extends Omit<React.ComponentProps<'div'>, 'title'> {
+    current: FamilyApp;
+    members?: ReadonlyArray<FamilyMember>;
+    creator?: FamilyCreator;
+    creatorLabel?: string;
+    hubUrl?: string;
+    label?: string;
+    blurb?: React.ReactNode;
+    ctaLabel?: string;
+    currentLabel?: string;
+    githubLabel?: string;
+    websiteLabel?: string;
+    theme?: LogoTheme;
+}
+declare const FamilyBadge: React.ForwardRefExoticComponent<Omit<FamilyBadgeProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface TechChipsProps extends React.ComponentProps<'div'> {
+    items: ReadonlyArray<string | null | undefined>;
+}
+declare const TechChips: React.ForwardRefExoticComponent<Omit<TechChipsProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface SponsorChannel {
+    id: string;
+    name: React.ReactNode;
+    href: string;
+    description?: React.ReactNode;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    external?: boolean;
+    highlight?: boolean;
+}
+interface SponsorCardProps extends Omit<React.ComponentProps<'section'>, 'title'> {
+    channels: ReadonlyArray<SponsorChannel>;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footnote?: React.ReactNode;
+    channelsLabel?: string;
+    /** Channel list columns. `auto` = one column below the `sm` viewport
+     * breakpoint, two above; `1`/`2` force a count (use `1` inside narrow
+     * surfaces like modals — breakpoints track the viewport, not the card). */
+    columns?: 'auto' | 1 | 2;
+    icon?: React.ReactNode;
+    heading?: 'h2' | 'h3' | 'h4';
+}
+declare const SponsorCard: React.ForwardRefExoticComponent<Omit<SponsorCardProps, "ref"> & React.RefAttributes<HTMLElement>>;
+
+interface AboutCreator {
+    name: React.ReactNode;
+    role?: React.ReactNode;
+    href?: string;
+    links?: ReadonlyArray<AboutLinkItem>;
+}
+interface AboutLicense {
+    name: string;
+    href?: string;
+}
+interface AboutNoteContent {
+    tone?: 'info' | 'warning';
+    title?: React.ReactNode;
+    children: React.ReactNode;
+}
+interface AboutSponsorContent {
+    channels: ReadonlyArray<SponsorChannel>;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    footnote?: React.ReactNode;
+    channelsLabel?: string;
+}
+interface AboutPanelProps extends React.ComponentProps<'div'> {
+    appName: string;
+    familyCurrent?: FamilyApp;
+    logo?: React.ReactNode;
+    tagline?: React.ReactNode;
+    description?: React.ReactNode;
+    version?: string;
+    license?: AboutLicense;
+    licenseTitle?: string;
+    licenseLinkLabel?: string;
+    links?: ReadonlyArray<AboutLinkItem>;
+    linksTitle?: string;
+    creator?: AboutCreator;
+    creatorTitle?: string;
+    tech?: ReadonlyArray<string>;
+    techTitle?: string;
+    note?: AboutNoteContent;
+    sponsor?: AboutSponsorContent;
+    familyMembers?: ReadonlyArray<FamilyMember>;
+    hubUrl?: string;
+    familyLabel?: string;
+    familyBlurb?: React.ReactNode;
+    familyCtaLabel?: string;
+    familyCurrentLabel?: string;
+    theme?: LogoTheme;
+    copyright?: React.ReactNode;
+}
+declare const AboutPanel: React.ForwardRefExoticComponent<Omit<AboutPanelProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface AiAction {
+    id: string;
+    label: string;
+    description?: string;
+    icon: LucideIcon;
+}
+interface AiActionsDropdownProps {
+    actions: AiAction[];
+    onAction: (action: AiAction) => void;
+    onPrompt?: (prompt: string) => void;
+    busy?: boolean;
+    error?: string | null;
+    label?: string;
+    title?: string;
+    promptLabel?: string;
+    promptPlaceholder?: string;
+    promptSubmitLabel?: string;
+    disabled?: boolean;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    className?: string;
+    panelClassName?: string;
+    primaryAction?: AiAction;
+    primaryLabel?: string;
+    moreLabel?: string;
+}
+declare const AiActionsDropdown: React.ForwardRefExoticComponent<AiActionsDropdownProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface AiButtonProps {
+    onSubmit: (prompt: string) => void;
+    suggestions?: string[];
+    onResponse?: React.ReactNode;
+    loading?: boolean;
+    error?: string | null;
+    label?: string;
+    promptLabel?: string;
+    submitLabel?: string;
+    loadingLabel?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Controlled open state (defaults to internal). */
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Show the label text next to the icon (default true; icon-only when false). */
+    showLabel?: boolean;
+    /** Close the panel after a submit (form-fill flows; Q&A keeps it open). */
+    closeOnSubmit?: boolean;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    align?: 'start' | 'center' | 'end';
+    className?: string;
+    panelClassName?: string;
+}
+declare const AiButton: React.ForwardRefExoticComponent<AiButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface AiMagicFillProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: (prompt: string) => void;
+    busy?: boolean;
+    error?: string | null;
+    title?: string;
+    subtitle?: string;
+    description?: string;
+    promptLabel?: string;
+    placeholder?: string;
+    submitLabel?: string;
+    cancelLabel?: string;
+    className?: string;
+}
+declare function AiMagicFill({ open, onOpenChange, onSubmit, busy, error, title, subtitle, description, promptLabel, placeholder, submitLabel, cancelLabel, className, }: AiMagicFillProps): React.JSX.Element;
+
+type FlowStepStatus = 'pending' | 'running' | 'done' | 'failed' | 'interrupted';
+interface FlowStep {
+    id: string;
+    label: string;
+    status: FlowStepStatus;
+}
+interface FlowError {
+    code: string;
+    message: string;
+    retryable: boolean;
+}
+interface FlowStatusCardProps {
+    /** Flow name, e.g. "Analyzing document". */
+    title: string;
+    /** Ordered steps, one per graph node. */
+    steps: FlowStep[];
+    /** Overall run status. */
+    status: FlowStepStatus;
+    /** Set when `status === 'failed'`. */
+    error?: FlowError;
+    /** Rendered only when `error?.retryable`. */
+    onRetry?: () => void;
+    /** Rendered while `status === 'running'`. */
+    onCancel?: () => void;
+    /** Rendered when `status === 'interrupted'`. */
+    onResume?: () => void;
+    /** Payload slot: HITL card, references, extra info. */
+    detail?: React.ReactNode;
+    /** Plain strings, i18n at call sites. */
+    labels?: Partial<Record<'retry' | 'cancel' | 'resume', string>>;
+    className?: string;
+}
+declare const FlowStatusCard: React.ForwardRefExoticComponent<FlowStatusCardProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "warning" | "success" | "danger" | "secondary" | "outline" | "ai" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BadgeProps extends React.ComponentProps<'span'>, VariantProps<typeof badgeVariants> {
+}
+declare const Badge: React.ForwardRefExoticComponent<Omit<BadgeProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    icon?: React.ReactNode;
+}
+interface BreadcrumbLinkProps {
+    href: string;
+    className?: string;
+    title?: string;
+    'aria-label'?: string;
+    children: React.ReactNode;
+}
+interface BreadcrumbsProps extends React.ComponentProps<'nav'> {
+    items?: BreadcrumbItem[];
+    currentLabel?: string;
+    homeHref?: string;
+    homeLabel?: string;
+    linkComponent?: React.ComponentType<BreadcrumbLinkProps>;
+}
+declare const Breadcrumbs: React.ForwardRefExoticComponent<Omit<BreadcrumbsProps, "ref"> & React.RefAttributes<HTMLElement>>;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "secondary" | "outline" | "ghost" | "destructive" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ComponentProps<'button'>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    loading?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<Omit<ButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+type ConnectionTestStatus = 'idle' | 'testing' | 'ok' | 'fail';
+interface ConnectionTestRowProps {
+    status: ConnectionTestStatus;
+    latencyMs?: number | null;
+    label?: string;
+    testLabel?: string;
+    okLabel?: string;
+    failLabel?: string;
+    latencyLabel?: string;
+    errorMessage?: string | null;
+    onTest?: () => void;
+    disabled?: boolean;
+    /** `row` = standalone bordered row; `inline` = bare, for embedding in app cards. */
+    variant?: 'row' | 'inline';
+    /** Extra app-side context rendered after the status (e.g. model count). */
+    meta?: React.ReactNode;
+    className?: string;
+}
+/**
+ * Presentational connection-test row (idle/testing/ok/fail + latency).
+ * The actual ping is app-side: flip `status` from the test handler.
+ */
+declare const ConnectionTestRow: React.ForwardRefExoticComponent<ConnectionTestRowProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ProviderFormProps extends React.ComponentProps<'div'> {
+    name: string;
+    onNameChange: (value: string) => void;
+    baseUrl: string;
+    onBaseUrlChange: (value: string) => void;
+    apiKey: string;
+    onApiKeyChange: (value: string) => void;
+    namePlaceholder?: string;
+    baseUrlPlaceholder?: string;
+    nameLabel?: string;
+    baseUrlLabel?: string;
+    /** Hide the base URL field for provider types that have a fixed endpoint. */
+    hideBaseUrl?: boolean;
+    apiKeyLabel?: string;
+    /** Optional Local/Cloud toggle — render only when `showLocationKind`. */
+    showLocationKind?: boolean;
+    locationKind?: 'local' | 'cloud';
+    onLocationKindChange?: (kind: 'local' | 'cloud') => void;
+    locationLabel?: string;
+    localLabel?: string;
+    cloudLabel?: string;
+    /** Optional country select — render only when `showCountry`. */
+    showCountry?: boolean;
+    country?: string;
+    onCountryChange?: (country: string) => void;
+    countryLabel?: string;
+    countryOptions?: {
+        value: string;
+        label: string;
+    }[];
+    countryPlaceholder?: string;
+    /** Hint under the key field; apps mention keyring storage here. */
+    apiKeyHelp?: string;
+    /** The provider already stores a key (write-only field shows no value). */
+    hasStoredKey?: boolean;
+    storedKeyLabel?: string;
+    keyPlaceholder?: string;
+    error?: string;
+    children?: React.ReactNode;
+}
+/**
+ * Standard provider credential fields: name, base URL and a **write-only**
+ * masked API key (`onChange` only — the library never renders a stored key;
+ * keyring/storage is the app's business, ADR-006).
+ */
+declare const ProviderForm: React.ForwardRefExoticComponent<Omit<ProviderFormProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface SettingsNavItem {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: LucideIcon;
+    /** Optional trailing node (status dot, count, badge) at the row edge. */
+    trailing?: React.ReactNode;
+}
+interface SettingsShellProps {
+    nav: SettingsNavItem[];
+    active: string;
+    onNavigate: (id: string) => void;
+    header?: {
+        icon?: LucideIcon;
+        title: string;
+    };
+    children: React.ReactNode;
+    className?: string;
+    navClassName?: string;
+    /** Test hook: data-testid for the `<nav>` element. */
+    navTestId?: string;
+}
+declare const SettingsShell: React.ForwardRefExoticComponent<SettingsShellProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Card: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface CheckIndicatorProps {
+    checked: boolean;
+    label: string;
+    onToggle: () => void;
+    mixed?: boolean;
+    className?: string;
+}
+declare const CheckIndicator: React.ForwardRefExoticComponent<CheckIndicatorProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface ChipInputProps extends Omit<React.ComponentProps<'div'>, 'onChange'> {
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    separators?: string[];
+    inputLabel?: string;
+    removeLabel?: string;
+    addLabel?: string;
+    hint?: string;
+    disabled?: boolean;
+}
+declare const ChipInput: React.ForwardRefExoticComponent<Omit<ChipInputProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+type ChipVariant = 'neutral' | 'primary' | 'info' | 'success' | 'warning' | 'danger';
+interface ChipListProps extends React.ComponentProps<'div'> {
+    items: ReadonlyArray<string | null | undefined>;
+    onRemove?: (item: string) => void;
+    onItemClick?: (value: string, index: number) => void;
+    variant?: ChipVariant;
+    emptyText?: string;
+    showChevron?: boolean;
+    removeLabel?: string;
+}
+declare const ChipList: React.ForwardRefExoticComponent<Omit<ChipListProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+    description?: string;
+    group?: string;
+    badge?: string;
+    disabled?: boolean;
+}
+interface ComboboxProps {
+    options: ComboboxOption[];
+    value?: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    searchLabel?: string;
+    emptyLabel?: string;
+    loadingLabel?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    clearable?: boolean;
+    clearLabel?: string;
+    /** Offer an "Add …" row for search terms that match no option. */
+    allowCreate?: boolean;
+    /** Custom label for the create row; receives the trimmed term. */
+    createLabel?: (term: string) => string;
+    onSearchChange?: (term: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    label?: string;
+    /** Keep the accessible name from `label` but do not render it visibly. */
+    hideLabel?: boolean;
+    error?: string;
+    id?: string;
+    className?: string;
+    panelClassName?: string;
+}
+declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLButtonElement>>;
+interface ComboboxMultiProps {
+    options: ComboboxOption[];
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    searchLabel?: string;
+    emptyLabel?: string;
+    loadingLabel?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    maxTriggerLabels?: number;
+    /** Offer an "Add …" row for search terms that match no option. */
+    allowCreate?: boolean;
+    /** Custom label for the create row; receives the trimmed term. */
+    createLabel?: (term: string) => string;
+    onSearchChange?: (term: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    label?: string;
+    error?: string;
+    id?: string;
+    className?: string;
+    panelClassName?: string;
+}
+declare const ComboboxMulti: React.ForwardRefExoticComponent<ComboboxMultiProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface ConfirmationModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    destructive?: boolean;
+    busy?: boolean;
+    onConfirm: () => void;
+    icon?: LucideIcon;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    closeLabel?: string;
+}
+declare function ConfirmationModal({ open, onOpenChange, title, description, confirmLabel, cancelLabel, destructive, busy, onConfirm, icon: Icon, size, closeLabel, }: ConfirmationModalProps): React.JSX.Element;
+
+interface CopyButtonProps extends Omit<React.ComponentProps<'button'>, 'value' | 'children'> {
+    value: string;
+    label?: string;
+    size?: number;
+    hideWhenEmpty?: boolean;
+    copiedDuration?: number;
+    onCopied?: () => void;
+    onCopyError?: (error: unknown) => void;
+}
+declare const CopyButton: React.ForwardRefExoticComponent<Omit<CopyButtonProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+interface ContextMenuItem {
+    key: string;
+    label: string;
+    icon?: LucideIcon;
+    onSelect?: () => void;
+    danger?: boolean;
+    disabled?: boolean;
+    hint?: string;
+}
+interface ContextMenuProps {
+    x: number;
+    y: number;
+    items: ContextMenuItem[];
+    onClose: () => void;
+    className?: string;
+}
+declare function ContextMenu({ x, y, items, onClose, className }: ContextMenuProps): React.JSX.Element;
+
+interface DatePickerProps {
+    value: string | null | undefined;
+    onChange: (value: string) => void;
+    onClear?: () => void;
+    allowClear?: boolean;
+    clearLabel?: string;
+    placeholder?: string;
+    displayFormat?: string;
+    minDate?: Date;
+    maxDate?: Date;
+    weekStartsOn?: 0 | 1;
+    disabled?: boolean;
+    required?: boolean;
+    variant?: 'default' | 'unstyled';
+    id?: string;
+    name?: string;
+    label?: string;
+    prevLabel?: string;
+    nextLabel?: string;
+    className?: string;
+    panelClassName?: string;
+}
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface EmptyStateProps extends React.ComponentProps<'div'> {
+    icon?: LucideIcon;
+    title: string;
+    description?: string;
+    action?: React.ReactNode;
+    compact?: boolean;
+}
+declare const EmptyState: React.ForwardRefExoticComponent<Omit<EmptyStateProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface ErrorBannerProps {
+    message: string | null | undefined;
+    action?: React.ReactNode;
+    className?: string;
+}
+declare function ErrorBanner({ message, action, className }: ErrorBannerProps): React.JSX.Element | null;
+
+interface ExpandableSearchProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    onClear?: () => void;
+    placeholder: string;
+    ariaLabel: string;
+    clearLabel?: string;
+    expandLabel?: string;
+    className?: string;
+}
+declare const ExpandableSearch: React.ForwardRefExoticComponent<ExpandableSearchProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FieldLabelProps {
+    children: React.ReactNode;
+    info: React.ReactNode;
+    infoTitle?: React.ReactNode;
+    label?: string;
+    showOnHover?: boolean;
+    className?: string;
+}
+declare function FieldLabel({ children, info, infoTitle, label, showOnHover, className, }: FieldLabelProps): React.JSX.Element;
+
+interface FormModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: LucideIcon;
+    headerActions?: React.ReactNode;
+    children: React.ReactNode;
+    onSubmit?: () => void;
+    submitting?: boolean;
+    submitDisabled?: boolean;
+    submitLabel?: string;
+    cancelLabel?: string;
+    closeLabel?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    contentClassName?: string;
+    bodyClassName?: string;
+    footer?: React.ReactNode;
+    hideFooter?: boolean;
+    onReject?: () => void;
+    rejectLabel?: string;
+}
+declare function FormModal({ open, onOpenChange, title, description, icon: Icon, headerActions, children, onSubmit, submitting, submitDisabled, submitLabel, cancelLabel, closeLabel, size, contentClassName, bodyClassName, footer, hideFooter, onReject, rejectLabel, }: FormModalProps): React.JSX.Element;
+
+interface InfoButtonProps {
+    children: React.ReactNode;
+    title?: React.ReactNode;
+    label?: string;
+    showOnHover?: boolean;
+    openOnHover?: boolean;
+    className?: string;
+}
+declare function InfoButton({ children, title, label, showOnHover, openOnHover, className, }: InfoButtonProps): React.JSX.Element;
+
+interface InputProps extends React.ComponentProps<'input'> {
+    label?: React.ReactNode;
+    hint?: React.ReactNode;
+    error?: string;
+}
+declare const Input: React.ForwardRefExoticComponent<Omit<InputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+
+interface Rect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+declare function rectsIntersect(a: Rect, b: Rect): boolean;
+declare function marqueeRect(startX: number, startY: number, currentX: number, currentY: number): Rect;
+declare function hitTestIds(container: HTMLElement, marquee: Rect): string[];
+type MarqueePhase = 'start' | 'drag' | 'end';
+interface UseMarqueeOptions {
+    enabled: boolean;
+    containerRef: {
+        current: HTMLElement | null;
+    };
+    getBaseSelection: () => Set<string>;
+    onSelect: (ids: string[], phase: MarqueePhase) => void;
+}
+declare function useMarquee({ enabled, containerRef, getBaseSelection, onSelect, }: UseMarqueeOptions): {
+    band: Rect | null;
+};
+declare function MarqueeBand({ band }: {
+    band: Rect | null;
+}): React.JSX.Element | null;
+interface MarqueeSelection {
+    selected: Set<string>;
+    set: (ids: string[]) => void;
+    clear: () => void;
+}
+interface MarqueeSurfaceProps extends React.ComponentProps<'div'> {
+    children: React.ReactNode;
+    selection: MarqueeSelection;
+    clearBlocked?: () => boolean;
+}
+declare const MarqueeSurface: React.ForwardRefExoticComponent<Omit<MarqueeSurfaceProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const Menu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const MenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const MenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface MenuItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> {
+    icon?: LucideIcon;
+    danger?: boolean;
+    pending?: boolean;
+}
+declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface MenuCheckboxItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem> {
+    icon?: LucideIcon;
+    danger?: boolean;
+    pending?: boolean;
+}
+declare const MenuCheckboxItem: React.ForwardRefExoticComponent<MenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const MenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface ActionMenuItem {
+    key: string;
+    label: string;
+    icon?: LucideIcon;
+    danger?: boolean;
+    disabled?: boolean;
+    pending?: boolean;
+    onSelect: () => void;
+}
+interface ActionMenuProps {
+    label: string;
+    trigger: React.ReactNode;
+    items: ActionMenuItem[];
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    triggerClassName?: string;
+    panelClassName?: string;
+    disabled?: boolean;
+}
+declare function ActionMenu({ label, trigger, items, align, side, triggerClassName, panelClassName, disabled, }: ActionMenuProps): React.JSX.Element;
+
+interface UserMenuItem {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    tone?: 'default' | 'danger';
+    disabled?: boolean;
+    pending?: boolean;
+    /** Renders as a checkable item (aria-checked) — e.g. theme/language toggles. */
+    checked?: boolean;
+}
+interface UserMenuProps {
+    name?: string;
+    email?: string;
+    avatarUrl?: string;
+    /** Fallback disc text when no avatarUrl; derived from `name` when omitted. */
+    initials?: string;
+    items: UserMenuItem[];
+    onItemSelect: (id: string) => void;
+    align?: 'start' | 'end';
+    labels?: {
+        openMenu?: string;
+    };
+    className?: string;
+}
+declare const UserMenu: React.ForwardRefExoticComponent<UserMenuProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Modal: React.FC<DialogPrimitive.DialogProps>;
+declare const ModalTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const ModalClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const modalContentVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ModalContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof modalContentVariants> {
+    closeLabel?: string;
+}
+declare const ModalContent: React.ForwardRefExoticComponent<ModalContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ModalHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ModalTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const ModalDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const ModalFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const panelModalVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface PanelModalProps extends Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, 'title'>, VariantProps<typeof panelModalVariants> {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title?: React.ReactNode;
+    headerIcon?: React.ReactNode;
+    headerActions?: React.ReactNode;
+    footer?: React.ReactNode;
+    hideHeader?: boolean;
+    bodyClassName?: string;
+    closeLabel?: string;
+}
+/**
+ * Dialog panel with a header (icon, title, actions, close), scrollable body
+ * and optional sticky footer — full-screen on mobile, centered card on
+ * desktop. For plain dialogs prefer the `Modal` parts; for forms prefer
+ * `FormModal`.
+ */
+declare const PanelModal: React.ForwardRefExoticComponent<PanelModalProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverClose: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface PopoverButtonProps {
+    trigger: React.ReactNode;
+    children: React.ReactNode | (() => React.ReactNode);
+    label: string;
+    align?: 'start' | 'center' | 'end';
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    sideOffset?: number;
+    panelClassName?: string;
+    triggerClassName?: string;
+    openOnHover?: boolean;
+    focusOnOpen?: boolean;
+    preserveFocus?: boolean;
+    closeSignal?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+}
+declare function PopoverButton({ trigger, children, label, align, side, sideOffset, panelClassName, triggerClassName, openOnHover, focusOnOpen, preserveFocus, closeSignal, open: openProp, defaultOpen, onOpenChange, disabled, }: PopoverButtonProps): React.JSX.Element;
+
+interface RangeBarProps extends React.ComponentProps<'div'> {
+    low: number;
+    high: number;
+    min?: number;
+    max?: number;
+    value?: number | null;
+    unit?: string;
+    label?: string;
+    valueLabel?: string;
+}
+declare const RangeBar: React.ForwardRefExoticComponent<Omit<RangeBarProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface ScaleSliderProps extends Omit<React.ComponentProps<'div'>, 'onChange'> {
+    value: number | '' | null | undefined;
+    onChange: (value: number | '') => void;
+    min: number;
+    max: number;
+    step?: number;
+    lowLabel?: string;
+    highLabel?: string;
+    showInput?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+declare function scaleColorForValue(min: number, max: number, value: number | '' | null | undefined): string;
+declare const ScaleSlider: React.ForwardRefExoticComponent<Omit<ScaleSliderProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface SearchInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    placeholder: string;
+    ariaLabel: string;
+    autoFocus?: boolean;
+    clearLabel?: string;
+    className?: string;
+}
+declare const SearchInput: React.ForwardRefExoticComponent<SearchInputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface ModelPickerModel {
+    id: string;
+    name: string;
+    /** Short capability chip, e.g. `vision` or `tools`. */
+    capability?: string;
+    /** Full capability set, matched by TaskAssignmentPicker `requires`. */
+    capabilities?: string[];
+}
+interface ModelPickerProvider {
+    id: string;
+    name: string;
+    models: ModelPickerModel[];
+}
+interface ModelPickerProps {
+    providers: ModelPickerProvider[];
+    value?: string;
+    onChange: (modelId: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    searchLabel?: string;
+    emptyLabel?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    clearable?: boolean;
+    clearLabel?: string;
+    label?: string;
+    /** Keep the accessible name from `label` but do not render it visibly. */
+    hideLabel?: boolean;
+    error?: string;
+    id?: string;
+    className?: string;
+    panelClassName?: string;
+}
+/**
+ * Grouped, searchable provider → model picker. Presentational: the model
+ * list comes in via props, selection goes out via `onChange`.
+ */
+declare const ModelPicker: React.ForwardRefExoticComponent<ModelPickerProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface CapabilityDescriptor {
+    value: string;
+    label: string;
+    icon?: LucideIcon;
+}
+interface CapabilityChipsProps {
+    caps: CapabilityDescriptor[];
+    selected: string[];
+    onToggle?: (value: string) => void;
+    variant?: 'toggle' | 'badge';
+    minSelected?: number;
+    disabled?: boolean;
+    ariaLabel?: string;
+    className?: string;
+}
+declare const CapabilityChips: React.ForwardRefExoticComponent<CapabilityChipsProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ModelRegistryProvider {
+    id: string;
+    name: string;
+    type?: string;
+    baseUrl?: string;
+    /** Read-only provider: hides Add/Edit/Remove (e.g. org-managed providers). */
+    readOnly?: boolean;
+}
+interface ModelRegistryModel {
+    id: string;
+    providerId: string;
+    externalId: string;
+    label?: string;
+    caps: string[];
+    enabled: boolean;
+    reasoningEffort?: string;
+    temperature?: number | null;
+    maxTokens?: number | null;
+    /** App-defined extra fields (see `extraFields`), carried verbatim. */
+    extra?: Record<string, string>;
+    missing?: boolean;
+}
+interface ModelRegistryRemoteModel {
+    id: string;
+    caps: string[];
+}
+interface ModelRegistryDraft {
+    externalId: string;
+    label?: string;
+    caps: string[];
+    reasoningEffort?: string;
+    temperature?: number | null;
+    maxTokens?: number | null;
+    extra?: Record<string, string>;
+}
+interface ModelRegistryPatch {
+    label?: string;
+    caps?: string[];
+    reasoningEffort?: string;
+    temperature?: number | null;
+    maxTokens?: number | null;
+    extra?: Record<string, string>;
+}
+interface ModelRegistryExtraField {
+    key: string;
+    label: string;
+    placeholder?: string;
+    /** Render a multi-line textarea instead of a single-line input. */
+    multiline?: boolean;
+}
+type ModelRegistryRemoteState = 'loading' | 'error' | 'ready';
+interface ModelRegistryProps {
+    providers: ModelRegistryProvider[];
+    models: ModelRegistryModel[];
+    caps: CapabilityDescriptor[];
+    expandedProviderId?: string | null;
+    onExpandedProviderChange: (providerId: string | null) => void;
+    remoteModels?: ModelRegistryRemoteModel[];
+    remoteState?: ModelRegistryRemoteState;
+    remoteError?: string | null;
+    onRetryRemote?: () => void;
+    onAddModel: (providerId: string, draft: ModelRegistryDraft) => void;
+    onAddAll?: (providerId: string, drafts: ModelRegistryDraft[]) => void;
+    onUpdateModel: (model: ModelRegistryModel, patch: ModelRegistryPatch) => void;
+    onDeleteModel: (model: ModelRegistryModel) => void;
+    /** Toggle a model's enabled flag; renders the row checkbox when set. */
+    onToggleEnabled?: (model: ModelRegistryModel, enabled: boolean) => void;
+    enableLabel?: string;
+    /** App-declared extra fields rendered in the add/edit modal (e.g. a
+     *  description line); values ride `extra` on Draft/Patch/Model. */
+    extraFields?: ModelRegistryExtraField[];
+    reasoningEffortOptions?: string[];
+    addLabel?: string;
+    addAllLabel?: string;
+    addTitle?: string;
+    editTitle?: string;
+    selectModelLabel?: string;
+    manualIdToggleLabel?: string;
+    editLabel?: string;
+    removeLabel?: string;
+    missingLabel?: string;
+    capsLabel?: string;
+    /** Muted explainer under the capability chips (what they gate). */
+    capsHint?: string;
+    searchPlaceholder?: string;
+    searchLabel?: string;
+    emptyProviderLabel?: string;
+    externalIdRequiredLabel?: string;
+    remoteEmptyLabel?: string;
+    remoteLoadingLabel?: string;
+    retryLabel?: string;
+    customOptionLabel?: string;
+    temperatureLabel?: string;
+    maxTokensLabel?: string;
+    labelLabel?: string;
+    reasoningEffortLabel?: string;
+    saveLabel?: string;
+    cancelLabel?: string;
+    addDraftLabel?: string;
+    providersEmptyLabel?: string;
+    emptyAction?: React.ReactNode;
+    className?: string;
+}
+declare const ModelRegistry: React.ForwardRefExoticComponent<ModelRegistryProps & React.RefAttributes<HTMLDivElement>>;
+
+interface SelectionBarProps {
+    count: number;
+    onClear: () => void;
+    countLabel?: React.ReactNode;
+    clearLabel?: string;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function SelectionBar({ count, onClear, countLabel, clearLabel, children, className, }: SelectionBarProps): React.JSX.Element | null;
+
+interface NavChild {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    badge?: string | number;
+    /** Divider label rendered above this child (first occurrence only). */
+    section?: string;
+    disabled?: boolean;
+}
+interface NavItem {
+    id: string;
+    label: string;
+    icon?: LucideIcon;
+    badge?: string | number;
+    /** One nesting level; deeper trees stay app-side. */
+    children?: NavChild[];
+    disabled?: boolean;
+    /** Divider label rendered above this item (first occurrence only) —
+     * for flat sidebars with visual groups. Ignored in the collapsed rail. */
+    section?: string;
+}
+interface SidebarNavLabels {
+    /** aria-label on the <nav> element. */
+    navAria?: string;
+    /** Collapsed-rail toggle title when collapsed. */
+    expand?: string;
+    /** Collapsed-rail toggle title when expanded. */
+    collapse?: string;
+    /** aria-label for a collapsed group's flyout trigger. */
+    openGroup?: string;
+}
+interface SidebarNavProps {
+    /** Pre-filtered by the app (roles, feature flags); order = render order. */
+    items: NavItem[];
+    /** Flat items pinned below the scroll area, above `footer` (the
+     * Settings/About pattern). Same rendering, active state, rail behavior
+     * and keyboard traversal order as `items`. */
+    secondaryItems?: NavItem[];
+    /** The app resolves route → id; matching logic stays app-side. */
+    activeId?: string | null;
+    /** Fires for leaves only; group triggers toggle expansion instead. */
+    onNavigate?: (id: string) => void;
+    /** Controlled icon rail. */
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Renders the rail collapse/expand toggle handle (desktop only). */
+    collapsible?: boolean;
+    /** Controlled group expansion; uncontrolled defaults to internal
+     * state + auto-expand when activeId enters a group. */
+    expandedIds?: string[];
+    onExpandedIdsChange?: (ids: string[]) => void;
+    /** Slot above the list (brand, logo). */
+    header?: React.ReactNode;
+    /** Slot below the list and pinned items (version, legal links). */
+    footer?: React.ReactNode;
+    /** Denser layout for short viewports: tighter item padding, smaller
+     * icons/typography, slimmer regions. Presentational only — the app
+     * decides when (e.g. a `max-height` media query). Composes with
+     * `collapsed`. */
+    compact?: boolean;
+    labels?: SidebarNavLabels;
+    className?: string;
+    /** Targets the scrollable list region. */
+    navClassName?: string;
+}
+declare const SidebarNav: React.ForwardRefExoticComponent<SidebarNavProps & React.RefAttributes<HTMLElement>>;
+
+declare const sizeClasses: {
+    readonly sm: "size-3.5";
+    readonly md: "size-4";
+    readonly lg: "size-6";
+};
+interface SpinnerProps extends React.ComponentProps<'span'> {
+    size?: keyof typeof sizeClasses;
+    label?: string;
+}
+declare const Spinner: React.ForwardRefExoticComponent<Omit<SpinnerProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+
+interface TaskAssignmentTask {
+    id: string;
+    label: string;
+    description?: string;
+    /** Rendered in an icon tile at the row's leading edge. */
+    icon?: LucideIcon;
+    /** When set, the row's picker offers only models matching this capability. */
+    requires?: string;
+    /** Render the fallback-model picker for this row (needs `onAssignSecondary`). */
+    secondary?: boolean;
+    /**
+     * The row's assignment itself is a fallback (e.g. an app's global default
+     * model): render only the fallback picker, no primary picker. Implies
+     * `secondary` — the value round-trips via `secondaryValue`/`onAssignSecondary`.
+     */
+    secondaryOnly?: boolean;
+}
+interface TaskAssignmentSection {
+    id: string;
+    label: string;
+    /** Muted context line under the section label (e.g. what the rows mean). */
+    description?: string;
+    /** Show the fallback picker on every task in the section (task-level wins). */
+    secondary?: boolean;
+    tasks: TaskAssignmentTask[];
+}
+interface TaskAssignmentPickerProps {
+    /** Flat rendering; ignored when `sections` is set. */
+    tasks?: TaskAssignmentTask[];
+    /** Grouped rendering; when set, `tasks` is ignored. */
+    sections?: TaskAssignmentSection[];
+    providers: ModelPickerProvider[];
+    /** Current mapping: taskId → modelId (null/undefined = unassigned). */
+    value: Record<string, string | null>;
+    onAssign: (taskId: string, modelId: string | null) => void;
+    /** Enables fallback-model rows for tasks flagged (directly or via section). */
+    secondaryValue?: Record<string, string | null>;
+    onAssignSecondary?: (taskId: string, modelId: string | null) => void;
+    secondaryLabel?: string;
+    /** Compact badge text for the primary picker (default "Primary"). */
+    primaryLabel?: string;
+    /** Info-popup content for the primary picker (rendered when set). */
+    primaryInfo?: React.ReactNode;
+    /** Info-popup content for the fallback picker (rendered when set). */
+    fallbackInfo?: React.ReactNode;
+    /** App-rendered per-row context (inherit notes, spend, badges). */
+    renderMeta?: (task: TaskAssignmentTask) => React.ReactNode;
+    clearLabel?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare const TaskAssignmentPicker: React.ForwardRefExoticComponent<TaskAssignmentPickerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface TableProps extends React.ComponentProps<'div'> {
+    headers: string[];
+    rows: React.ReactNode[][];
+    /** Rendered as a full-width row when the table is empty. No default. */
+    emptyText?: string;
+}
+declare const Table: React.ForwardRefExoticComponent<Omit<TableProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+type IconType = React.ComponentType<{
+    className?: string;
+}>;
+interface InfoTooltipProps {
+    content: React.ReactNode;
+    title?: string;
+    icon?: IconType;
+    side?: 'top' | 'bottom' | 'left' | 'right';
+    trigger?: 'hover' | 'click';
+    label?: string;
+    className?: string;
+}
+declare function InfoTooltip({ content, title, icon: Icon, side, trigger, label, className, }: InfoTooltipProps): React.JSX.Element;
+
+interface TimeListProps {
+    /** List of 24-hour `HH:MM` strings. */
+    value: string[];
+    /** Push the fully replaced list back to the parent. */
+    onChange: (next: string[]) => void;
+    /** Optional heading rendered above the chips. */
+    label?: string;
+    /** Optional helper text rendered under the label. */
+    hint?: string;
+    addLabel?: string;
+    emptyLabel?: string;
+    /** Cap the number of chips; renders a note when reached. */
+    maxItems?: number;
+    maxItemsLabel?: (n: number) => string;
+    removeLabel?: string;
+    /** Disable every chip + the add button. */
+    disabled?: boolean;
+    /** Diameter of the picker's clock face (default 220). */
+    clockSize?: number;
+    className?: string;
+}
+/**
+ * Chip-based editor for a list of `HH:MM` times: each chip opens the clock
+ * picker, an add pill appends a slot. For a single time use `TimePicker`.
+ */
+declare const TimeList: React.ForwardRefExoticComponent<TimeListProps & React.RefAttributes<HTMLDivElement>>;
+
+interface TimePickerProps {
+    /** 24-hour `HH:MM` string, or null/undefined when empty. */
+    value: string | null | undefined;
+    /** Fired with a 24-hour `HH:MM` string. */
+    onChange: (value: string) => void;
+    className?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    id?: string;
+    /** Diameter of the clock face in px (default 240). */
+    size?: number;
+    /** Accessible name for the trigger (also an optional visible label). */
+    label?: string;
+    hourLabel?: string;
+    minuteLabel?: string;
+    doneLabel?: string;
+    variant?: 'default' | 'unstyled';
+}
+interface TimePickerContentProps {
+    value: string | null | undefined;
+    onChange: (value: string) => void;
+    onDone?: () => void;
+    size?: number;
+    hourLabel?: string;
+    minuteLabel?: string;
+    doneLabel?: string;
+    className?: string;
+}
+/**
+ * The popover body: editable HH:MM inputs + AM/PM segmented control + clock
+ * face + Done button. Owns a working copy of the time, seeded from `value`
+ * once on mount (the parent unmounts it when the popover closes).
+ */
+declare const TimePickerContent: React.FC<TimePickerContentProps>;
+declare const TimePicker: React.ForwardRefExoticComponent<TimePickerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface UndoNoticeProps {
+    message?: string;
+    actionLabel?: string;
+    onUndo: () => void;
+    undoing?: boolean;
+    duration?: number;
+    onDismiss: () => void;
+    className?: string;
+}
+declare function UndoNotice({ message, actionLabel, onUndo, undoing, duration, onDismiss, className, }: UndoNoticeProps): React.JSX.Element;
+
+type ViewToggleView = 'grid' | 'list';
+interface ViewToggleProps {
+    view: ViewToggleView;
+    onChange: (view: ViewToggleView) => void;
+    gridLabel?: string;
+    listLabel?: string;
+    className?: string;
+}
+declare function ViewToggle({ view, onChange, gridLabel, listLabel, className, }: ViewToggleProps): React.JSX.Element;
+
+interface StepperStep {
+    id: string;
+    label?: React.ReactNode;
+    icon?: LucideIcon;
+}
+interface StepperProps {
+    steps: StepperStep[];
+    current: number;
+    variant?: 'dots' | 'labels';
+    onStepClick?: (index: number) => void;
+    className?: string;
+}
+declare function Stepper({ steps, current, variant, onStepClick, className, }: StepperProps): React.JSX.Element;
+interface WizardStep {
+    id: string;
+    icon?: LucideIcon;
+    title?: React.ReactNode;
+    subtitle?: React.ReactNode;
+    canContinue?: boolean;
+    nextLabel?: string;
+    hideFooter?: boolean;
+}
+interface WizardContext {
+    id: string;
+    index: number;
+    step: WizardStep;
+    isFirst: boolean;
+    isLast: boolean;
+    next: () => void;
+    back: () => void;
+    goTo: (index: number) => void;
+}
+interface WizardProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: React.ReactNode;
+    steps: WizardStep[];
+    renderStep: (ctx: WizardContext) => React.ReactNode;
+    initialStep?: number;
+    step?: number;
+    onStepChange?: (index: number) => void;
+    onSkip?: () => void;
+    skipLabel?: string | null;
+    backLabel?: string;
+    nextLabel?: string;
+    getStartedLabel?: string;
+    closeLabel?: string;
+    variant?: 'modal' | 'drawer';
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    contentClassName?: string;
+}
+declare function Wizard({ open, onOpenChange, title, steps, renderStep, initialStep, step: stepProp, onStepChange, onSkip, skipLabel, backLabel, nextLabel, getStartedLabel, closeLabel, variant, size, contentClassName, }: WizardProps): React.JSX.Element;
+
+type RichTextToolbarGroup = 'history' | 'heading' | 'format' | 'list' | 'quote';
+type RichTextHeadingLevel = 1 | 2 | 3 | 4;
+interface RichTextEditorLabels {
+    toolbar?: string;
+    bold?: string;
+    italic?: string;
+    strike?: string;
+    code?: string;
+    heading?: (level: number) => string;
+    bulletList?: string;
+    orderedList?: string;
+    blockquote?: string;
+    undo?: string;
+    redo?: string;
+}
+interface RichTextEditorIcons {
+    bold?: LucideIcon;
+    italic?: LucideIcon;
+    strike?: LucideIcon;
+    code?: LucideIcon;
+    heading?: LucideIcon;
+    bulletList?: LucideIcon;
+    orderedList?: LucideIcon;
+    blockquote?: LucideIcon;
+    undo?: LucideIcon;
+    redo?: LucideIcon;
+}
+interface RichTextEditorProps {
+    value: string;
+    onValueChange: (markdown: string) => void;
+    ariaLabel: string;
+    disabled?: boolean;
+    toolbar?: RichTextToolbarGroup[] | false;
+    /** App-owned controls at the end of the toolbar; render-prop form receives the editor. */
+    toolbarExtra?: React.ReactNode | ((editor: Editor | null) => React.ReactNode);
+    /** Full override of the document extension set; default is `[StarterKit, Markdown]`. Apps declare their complete set. */
+    extensions?: Extensions;
+    /** Extra classes for the editable region (merged after the built-ins via tailwind-merge). */
+    contentClassName?: string;
+    /** Called once when the editor instance is created and again with `null` on destroy/unmount. */
+    onReady?: (editor: Editor | null) => void;
+    /** Heading toggles rendered for the `heading` toolbar group, one button per level. */
+    headingLevels?: RichTextHeadingLevel[];
+    /** Map incoming app-domain markdown before it reaches the document. */
+    parseMarkdown?: (markdown: string) => string;
+    /** Map the serialized document before it is emitted / echo-compared. */
+    serializeMarkdown?: (markdown: string) => string;
+    labels?: Partial<RichTextEditorLabels>;
+    icons?: Partial<RichTextEditorIcons>;
+    className?: string;
+}
+declare const RichTextEditor: React.ForwardRefExoticComponent<RichTextEditorProps & React.RefAttributes<HTMLDivElement>>;
+
+type DictationStatus = 'idle' | 'recording' | 'transcribing';
+interface DictationError {
+    kind: 'unsupported' | 'denied' | 'unassigned' | 'failed';
+    detail?: string;
+}
+interface DictationResult {
+    text: string;
+}
+interface UseDictationOptions {
+    /** App-owned transport: upload the blob, resolve with the transcript. */
+    transcribe: (audio: Blob) => Promise<DictationResult>;
+    /** Map a transport failure to a structured error (e.g. 409 → 'unassigned'). */
+    classifyError?: (error: unknown) => DictationError;
+    /** Called with the transcript on success. */
+    onResult?: (text: string) => void;
+}
+declare function useDictation(options: UseDictationOptions): {
+    status: DictationStatus;
+    seconds: number;
+    error: DictationError | null;
+    levelRef: React.RefObject<number>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    cancel: () => void;
+    dismissError: () => void;
+};
+
+interface DictationButtonProps {
+    status: DictationStatus;
+    onStart: () => void;
+    /** Accessible name / tooltip. English default: 'Dictate'. */
+    label?: string;
+    recordingLabel?: string;
+    className?: string;
+}
+declare function DictationButton({ status, onStart, label, recordingLabel, className, }: DictationButtonProps): React.JSX.Element;
+interface DictationStripLabels {
+    recording?: string;
+    transcribing?: string;
+    stop?: string;
+    cancel?: string;
+    dismissError?: string;
+    unsupported?: string;
+    denied?: string;
+    unassigned?: string;
+    /** `{detail}` is interpolated with the transport error message. */
+    failed?: string;
+}
+interface DictationStripProps {
+    status: DictationStatus;
+    seconds: number;
+    levelRef: React.RefObject<number>;
+    error: DictationError | null;
+    labels?: Partial<DictationStripLabels>;
+    onStop: () => void;
+    onCancel: () => void;
+    onDismissError: () => void;
+    className?: string;
+}
+declare function DictationStrip({ status, seconds, levelRef, error, labels, onStop, onCancel, onDismissError, className, }: DictationStripProps): React.JSX.Element | null;
+
+type AiTextTransformStatus = 'idle' | 'running' | 'done' | 'error' | 'cancelled';
+interface AiTextTransformEventHandlers {
+    onDelta: (text: string) => void;
+    onDone: (result: string) => void;
+    onError: (message: string) => void;
+}
+interface AiTextTransformTransport {
+    /** Begin the job and resolve with its handle (e.g. a job id). */
+    start: () => Promise<string>;
+    /** Subscribe to a job's events; returns an unsubscribe function. */
+    subscribe: (jobId: string, handlers: AiTextTransformEventHandlers) => () => void;
+    cancel?: (jobId: string) => Promise<void>;
+    /** Optional status fallback when events may be missed. */
+    poll?: (jobId: string) => Promise<{
+        status: 'running' | 'done' | 'error' | 'cancelled';
+        result?: string;
+        error?: string;
+    }>;
+}
+interface UseAiTextTransformOptions {
+    transport: AiTextTransformTransport;
+    /** Status-fallback interval when `poll` is provided. Default 800 ms. */
+    pollIntervalMs?: number;
+    /** Hard timeout for a running job. Default 90 000 ms. */
+    timeoutMs?: number;
+    /** Streaming delta coalescing window. Default 50 ms. */
+    flushMs?: number;
+}
+/**
+ * Streaming text-transform state machine (idle → running → done/error/
+ * cancelled). Transport-injected: the app provides start/subscribe/cancel/
+ * poll closures over its own gateway; this hook owns status transitions,
+ * delta coalescing, the poll fallback and the hard timeout.
+ */
+declare function useAiTextTransform(options: UseAiTextTransformOptions): {
+    status: AiTextTransformStatus;
+    result: string;
+    error: string | null;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    reset: () => void;
+};
+
+interface TextDiffViewLabels {
+    original?: string;
+    suggested?: string;
+    /** Fold summary for a run of hidden unchanged lines. */
+    unchangedLines?: (count: number) => string;
+    showLess?: string;
+    prevChange?: string;
+    nextChange?: string;
+    changePosition?: (index: number, total: number) => string;
+}
+interface TextDiffViewProps {
+    original: string;
+    suggested: string;
+    /** Unchanged context lines kept visible around each changed block. Default 2. */
+    contextLines?: number;
+    showHeader?: boolean;
+    showNav?: boolean;
+    labels?: Partial<TextDiffViewLabels>;
+    /** Applied to the outer box. */
+    className?: string;
+    /** Applied to the scrolling body — size the view here (e.g. `max-h-64`). */
+    bodyClassName?: string;
+}
+declare const TextDiffView: React.ForwardRefExoticComponent<TextDiffViewProps & React.RefAttributes<HTMLDivElement>>;
+
+interface DiffSegment {
+    text: string;
+    changed: boolean;
+}
+interface DiffCell {
+    kind: 'add' | 'del' | 'context';
+    text: string;
+    no?: number;
+    segments?: DiffSegment[];
+}
+type DiffRow = {
+    kind: 'pair';
+    left: DiffCell | null;
+    right: DiffCell | null;
+} | {
+    kind: 'fold';
+    count: number;
+    hidden: DiffRow[];
+};
+interface LineDiffOptions {
+    contextLines?: number;
+}
+interface LineDiffResult {
+    rows: DiffRow[];
+    added: number;
+    removed: number;
+}
+declare function wordSegments(original: string, suggested: string): {
+    left: DiffSegment[];
+    right: DiffSegment[];
+};
+declare function computeLineDiff(original: string, suggested: string, options?: LineDiffOptions): LineDiffResult;
+
+type ChatRole = 'user' | 'assistant' | 'system';
+type ChatMessageStatus = 'streaming' | 'done' | 'error' | 'interrupted';
+interface ChatError {
+    code: string;
+    message: string;
+    retryable: boolean;
+}
+interface ChatMessageVariants {
+    /** 1-based position of this message among its siblings. */
+    index: number;
+    count: number;
+    siblingIds: string[];
+}
+interface ChatAttachmentView {
+    id: string;
+    name: string;
+    kind: 'image' | 'file';
+    /** Resolvable URL for previews (blob:, data:, or app API path). */
+    url?: string;
+    meta?: Record<string, unknown>;
+}
+/**
+ * The normalized message every chat renderer in the library speaks. Apps map
+ * their persisted rows onto this shape; unknown extras survive in `meta`.
+ */
+interface ChatMessageView {
+    id: string;
+    role: ChatRole;
+    /** Markdown body. */
+    content: string;
+    /** Thinking-mode text (family `delta kind="reasoning"` accumulation). */
+    reasoning?: string;
+    status: ChatMessageStatus;
+    error?: ChatError;
+    createdAt?: string | number;
+    /** Branch-tree linkage (family branching contract). */
+    parentId?: string | null;
+    variants?: ChatMessageVariants;
+    attachments?: ChatAttachmentView[];
+    /** App extension bag (trace refs, citations, chips…). */
+    meta?: Record<string, unknown>;
+}
+
+interface FlowStepInfo {
+    id: string;
+    label?: string;
+}
+/**
+ * Family streaming vocabulary (guidelines/ai-features.md §5), extended with
+ * the `tool_call` observation event. Transports map their wire format
+ * (SSE named events, WS topic payloads) onto these shapes app-side; the
+ * reducer tolerates unknown `event` values by ignoring them.
+ */
+type ChatStreamEvent = {
+    event: 'flow_started';
+    flow: string;
+    run_id?: string;
+    steps?: FlowStepInfo[];
+} | {
+    event: 'node_started';
+    node: string;
+    label?: string;
+    run_id?: string;
+} | {
+    event: 'node_finished';
+    node: string;
+    label?: string;
+    outcome: 'done' | 'failed' | 'interrupted';
+    run_id?: string;
+} | {
+    event: 'delta';
+    text: string;
+    kind?: 'text' | 'reasoning';
+    run_id?: string;
+} | {
+    event: 'tool_call';
+    id: string;
+    name: string;
+    title?: string;
+    status: 'running' | 'done' | 'failed';
+    args?: string;
+    result?: string;
+    durationMs?: number;
+    run_id?: string;
+} | {
+    event: 'interrupt';
+    payload: unknown;
+    run_id?: string;
+} | {
+    event: 'flow_finished';
+    result_ref?: string;
+    summary?: string;
+    run_id?: string;
+} | {
+    event: 'flow_failed';
+    code: string;
+    message: string;
+    retryable: boolean;
+    run_id?: string;
+};
+
+type LiveTurnStatus = 'idle' | 'pending' | 'streaming' | 'interrupted' | 'done' | 'error';
+interface LiveNodeState {
+    id: string;
+    label?: string;
+    status: 'pending' | 'running' | 'done' | 'failed' | 'interrupted';
+}
+interface LiveToolCall {
+    id: string;
+    name: string;
+    title?: string;
+    status: 'running' | 'done' | 'failed';
+    args?: string;
+    result?: string;
+    durationMs?: number;
+}
+/**
+ * Ephemeral state of the in-flight assistant turn. `text`/`reasoning` are
+ * `null` until the first delta (study's "not streaming yet" sentinel);
+ * `interrupted` is a resumable pause (HITL) unless `stopped` marks a user
+ * cancel; `stopped`/`done`/`error` are terminal for event intake.
+ */
+interface LiveTurnState {
+    status: LiveTurnStatus;
+    text: string | null;
+    reasoning: string | null;
+    toolCalls: LiveToolCall[];
+    nodes: LiveNodeState[];
+    error: ChatError | null;
+    interruptPayload: unknown | null;
+    runId: string | null;
+    stopped: boolean;
+    startedAt: number | null;
+    finishedAt: number | null;
+}
+type LiveTurnAction = {
+    type: 'send';
+    at: number;
+} | {
+    type: 'event';
+    event: ChatStreamEvent;
+    at?: number;
+} | {
+    type: 'stop';
+    at: number;
+} | {
+    type: 'reset';
+};
+declare const initialLiveTurnState: LiveTurnState;
+/**
+ * Pure state machine for one streamed assistant turn — the fixture-testable
+ * core behind `useChatStream` (same role career's `chatFlow.ts` plays for
+ * `FlowStatusCard`). Unknown event names are ignored (additive contract).
+ */
+declare function liveTurnReducer(state: LiveTurnState, action: LiveTurnAction): LiveTurnState;
+
+interface BranchNode {
+    id: string;
+    role: ChatRole;
+    excerpt?: string;
+    parentId: string | null;
+    activeChildId: string | null;
+    /** In insertion (sibling-order) order; the last entry is the newest sibling. */
+    childIds: string[];
+}
+interface BranchTree {
+    activeRootId: string | null;
+    nodes: Record<string, BranchNode>;
+}
+type BranchNodeInput = Omit<BranchNode, 'childIds'>;
+/**
+ * Index the server's branch-tree projection (family contract: the read-only
+ * `GET …/tree` shape) and compute child lists. Insertion order defines
+ * sibling order — the last child is the newest variant (fallback when a
+ * parent has no `activeChildId`).
+ */
+declare function buildBranchTree(input: {
+    activeRootId?: string | null;
+    nodes: BranchNodeInput[];
+}): BranchTree;
+/**
+ * Degenerate single-path tree from a visible (already active-path) message
+ * list — for apps/backends without branching yet. Every message parents to
+ * the previous one; the tree renders identically to a branched one.
+ */
+declare function linearTree(items: {
+    id: string;
+    role: ChatRole;
+    excerpt?: string;
+}[]): BranchTree;
+/**
+ * The visible conversation: pointer walk from the active root, following
+ * each node's `activeChildId` (fallback: newest sibling). Cycle-safe.
+ */
+declare function walkActivePath(tree: BranchTree): string[];
+declare function activePathSet(tree: BranchTree): Set<string>;
+/**
+ * Sibling variant info for the inline `‹ n/N ›` switcher: the 1-based index
+ * of `nodeId` among its siblings (roots are siblings of each other) and the
+ * ordered sibling ids.
+ */
+declare function variantInfo(tree: BranchTree, nodeId: string): {
+    index: number;
+    count: number;
+    siblingIds: string[];
+};
+
+interface ChatStreamTransport {
+    /** Enqueue/send a user turn. Resolves when accepted; errors surface as a failed turn. */
+    send(input: {
+        text: string;
+    }): Promise<void>;
+    /** Subscribe to the session's stream events; returns an unsubscribe function. */
+    subscribe(handlers: {
+        onEvent: (event: ChatStreamEvent) => void;
+    }): () => void;
+    /** Best-effort cancel of the in-flight turn (backend stop endpoint). */
+    stop?(): Promise<void>;
+}
+interface UseChatStreamOptions {
+    transport: ChatStreamTransport;
+    /** Delta coalescing window. Default 33 ms (study's rAF-scale budget). */
+    flushMs?: number;
+    /** Watchdog for a turn that never terminates. Default 90 000 ms. */
+    timeoutMs?: number;
+}
+interface UseChatStreamResult extends LiveTurnState {
+    /** The live turn, or `null` when idle — hand to the transcript's `live` slot. */
+    live: LiveTurnState | null;
+    /** Returns false and does nothing for blank input or while a turn is active. */
+    send(text: string): Promise<boolean>;
+    stop(): Promise<void>;
+    reset(): void;
+}
+/**
+ * Transport-injected live-turn state machine for chat surfaces: send →
+ * pending → streaming (coalesced text/reasoning deltas, tool calls, node
+ * progress) → done / error / interrupted. Persists nothing — the app owns
+ * sessions, messages and the branching endpoints; after a terminal state
+ * the app refetches and calls `reset()`.
+ */
+declare function useChatStream(options: UseChatStreamOptions): UseChatStreamResult;
+
+interface MarkdownCodeBlockLabels {
+    copy: string;
+    code: string;
+}
+interface MarkdownCodeBlockProps {
+    code: string;
+    language?: string;
+    showLanguage?: boolean;
+    labels?: Partial<MarkdownCodeBlockLabels>;
+    className?: string;
+}
+/**
+ * Standalone fenced-code surface: mono block, optional language tag, hover
+ * copy. Plain by design — no highlighting engine bundled (apps may wrap or
+ * slot their own renderer through `MarkdownSurface.components`).
+ */
+declare const MarkdownCodeBlock: React.ForwardRefExoticComponent<MarkdownCodeBlockProps & React.RefAttributes<HTMLDivElement>>;
+
+type MarkdownComponents = Components;
+
+interface MarkdownSurfaceProps {
+    /** Markdown source (model output is untrusted — raw HTML never renders). */
+    value: string;
+    /** Live turn: defers mermaid to the final render (streaming floods break diagrams). */
+    streaming?: boolean;
+    gfm?: boolean;
+    math?: boolean;
+    /** Render ```mermaid fences as diagrams (forced off while `streaming`). */
+    mermaid?: boolean;
+    mermaidTheme?: 'neutral' | 'default' | 'dark' | 'forest';
+    /** Per-key overrides of the default renderers (mentions, citations, links…). */
+    components?: MarkdownComponents;
+    urlTransform?: UrlTransform;
+    showCodeLanguage?: boolean;
+    labels?: Partial<MarkdownCodeBlockLabels>;
+    className?: string;
+}
+/**
+ * The family's read-only streaming markdown surface: GFM tables, KaTeX math
+ * (error-tolerant while streaming), lazily-imported mermaid diagrams, and
+ * copyable code blocks with language tags. Raw HTML is never rendered
+ * (no `rehype-raw`) — model output is untrusted input (ai-features §7).
+ */
+declare const MarkdownSurface: React.NamedExoticComponent<MarkdownSurfaceProps & React.RefAttributes<HTMLDivElement>>;
+
+interface MermaidDiagramProps {
+    code: string;
+    theme?: 'neutral' | 'default' | 'dark' | 'forest';
+    labels?: {
+        diagram?: string;
+    };
+    className?: string;
+}
+/**
+ * Lazily-rendered mermaid diagram (dynamic `import('mermaid')`, strict
+ * security). Falls back to the plain code block when rendering fails —
+ * study-assistant's proven behavior.
+ */
+declare const MermaidDiagram: React.ForwardRefExoticComponent<MermaidDiagramProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatMessageEditorLabels {
+    save: string;
+    cancel: string;
+    ariaLabel: string;
+}
+interface ChatMessageEditorProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    /** Save & resend — branches the tree (family `edit` endpoint) and reruns the turn. */
+    onSubmit: () => void;
+    onCancel: () => void;
+    submitDisabled?: boolean;
+    rows?: number;
+    labels?: Partial<ChatMessageEditorLabels>;
+    className?: string;
+}
+/**
+ * Inline user-prompt editor for the edit-and-resend flow (study pattern):
+ * controlled textarea, Cmd/Ctrl+Enter saves, Escape cancels.
+ */
+declare const ChatMessageEditor: React.ForwardRefExoticComponent<ChatMessageEditorProps & React.RefAttributes<HTMLDivElement>>;
+
+interface MessageVariantSwitcherLabels {
+    group: string;
+    variantOf: (index: number, count: number) => string;
+    previous: string;
+    next: string;
+}
+interface MessageVariantSwitcherProps {
+    variants: ChatMessageVariants;
+    /** Flip the parent's active-child pointer to the sibling id (family `select` endpoint). */
+    onSelect: (messageId: string) => void;
+    labels?: Partial<MessageVariantSwitcherLabels>;
+    className?: string;
+}
+/**
+ * The `‹ n/N ›` sibling-variant switcher under a branched message
+ * (study's inline switcher, family branching contract).
+ */
+declare const MessageVariantSwitcher: React.ForwardRefExoticComponent<MessageVariantSwitcherProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatMessageAction {
+    key: string;
+    label: string;
+    icon?: LucideIcon;
+    onClick: () => void;
+    danger?: boolean;
+}
+interface ChatMessageActions {
+    onCopy?: () => void;
+    onEdit?: () => void;
+    onRegenerate?: () => void;
+    onRetry?: () => void;
+    /** Extra icon actions (app-specific). */
+    extras?: ChatMessageAction[];
+}
+interface ChatMessageLabels {
+    copy: string;
+    edit: string;
+    regenerate: string;
+    retry: string;
+    interrupted: string;
+    error: string;
+}
+interface ChatMessageProps {
+    role: ChatRole;
+    /** Usually a `MarkdownSurface`; any node graph renders here. */
+    content: React.ReactNode;
+    /** Thinking block slot (usually `ChatReasoning`). */
+    reasoning?: React.ReactNode;
+    /** Tool cards / HITL cards below the content. */
+    children?: React.ReactNode;
+    status?: 'streaming' | 'done' | 'error' | 'interrupted';
+    error?: ChatError;
+    actions?: ChatMessageActions;
+    /** Edit-and-resend mode for user messages (renders `ChatMessageEditor`). */
+    editing?: false | {
+        value: string;
+        onValueChange: (value: string) => void;
+        onSubmit: () => void;
+        onCancel: () => void;
+        submitDisabled?: boolean;
+    };
+    variants?: ChatMessageVariants;
+    onSelectVariant?: (messageId: string) => void;
+    /** Badge row (model, latency, tokens — app-defined). */
+    meta?: React.ReactNode;
+    /** Deep-link chip row (career references, health citations). */
+    chips?: React.ReactNode;
+    /** Attachment rail above the content. */
+    attachments?: React.ReactNode;
+    labels?: Partial<ChatMessageLabels & ChatMessageEditorLabels & MessageVariantSwitcherLabels>;
+    compact?: boolean;
+    className?: string;
+}
+/**
+ * The family chat bubble: role-aligned, hover action row (copy / edit /
+ * regenerate + app extras), variant switcher under branched messages,
+ * reasoning and below-content slots, inline edit-and-resend, error +
+ * interrupted states. Presentational — state lives app-side.
+ */
+declare const ChatMessage: React.ForwardRefExoticComponent<ChatMessageProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatReasoningLabels {
+    title: string;
+    streaming: string;
+}
+interface ChatReasoningProps {
+    /** Accumulated reasoning text (family `delta kind="reasoning"`). */
+    text: string;
+    /** Live reasoning stream — spinner + streaming label while on. */
+    streaming?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    labels?: Partial<ChatReasoningLabels>;
+    icon?: LucideIcon;
+    className?: string;
+}
+/**
+ * Collapsible thinking block for reasoning models (study's
+ * `ReasoningBubble`, family-standard): streams live while the model
+ * reasons, collapses to a summary row when done. Controlled-first.
+ */
+declare const ChatReasoning: React.ForwardRefExoticComponent<ChatReasoningProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatToolCardLabels {
+    running: string;
+    done: string;
+    failed: string;
+    args: string;
+    result: string;
+    details: string;
+}
+interface ChatToolCardProps {
+    name: string;
+    /** Human title, e.g. "Searching the job catalog". */
+    title?: string;
+    status: 'running' | 'done' | 'failed';
+    /** Serialized arguments (JSON string or formatted text). */
+    args?: string;
+    /** Serialized result. */
+    result?: string;
+    /**
+     * Custom result view (study's per-tool views, family plan 12 L2).
+     * Called with the result string (possibly empty when the tool has no
+     * serialized output); when absent the default `<pre>` pane renders.
+     */
+    renderResult?: (result: string) => React.ReactNode;
+    durationMs?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    labels?: Partial<ChatToolCardLabels>;
+    icon?: LucideIcon;
+    className?: string;
+}
+/**
+ * Inline tool-call observation card (study's `ToolCallCard` + health's tool
+ * chips, generalized): status, duration, expandable args/result. The
+ * inspector stays app-side (health opens its own modal from `onOpenChange`
+ * or wrapping markup).
+ */
+declare const ChatToolCard: React.ForwardRefExoticComponent<ChatToolCardProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatTurnStatusLabels {
+    timer: string;
+}
+interface ChatTurnStatusProps {
+    /** Current turn phase, e.g. "searching the catalog". */
+    label: string;
+    /** Turn start timestamp (ms). Presence enables the elapsed timer. */
+    startedAt?: number;
+    /** `row` = inline pre-text line; `card` = soft surface block. */
+    variant?: 'row' | 'card';
+    /** Elapsed-timer refresh interval. Default 100 ms (study-proven). */
+    tickMs?: number;
+    labels?: Partial<ChatTurnStatusLabels>;
+    className?: string;
+}
+/**
+ * Live pre-text turn status (study's `TurnTraceStatus` + `ThinkingDots`,
+ * generalized for family plan 12 L1): animated dots + phase label, with
+ * an optional elapsed timer. Presentational and controlled — the turn
+ * state itself lives in `useChatStream`; this only narrates it.
+ */
+declare const ChatTurnStatus: React.ForwardRefExoticComponent<ChatTurnStatusProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatComposerLabels {
+    send: string;
+    stop: string;
+    placeholder: string;
+    ariaLabel: string;
+    dropFiles: string;
+}
+interface ChatComposerIcons {
+    send: LucideIcon;
+    stop: LucideIcon;
+}
+interface ChatComposerProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    /** Enter / Send — IME-safe (composition and keyCode 229 are ignored). */
+    onSubmit: () => void;
+    /** A turn is in flight — renders the stop control when `onStop` is provided. */
+    sending?: boolean;
+    onStop?: () => void;
+    disabled?: boolean;
+    placeholder?: string;
+    ariaLabel?: string;
+    /** Auto-grow cap before the textarea scrolls. Default 8. */
+    maxRows?: number;
+    /** Leading slot inside the input row (attach menu, equation, draw…). */
+    toolbarStart?: React.ReactNode;
+    /** Trailing slot inside the input row (dictation, tools…). */
+    toolbarEnd?: React.ReactNode;
+    /** Attachment rail above the input (usually `FileQueue` / chips). */
+    attachments?: React.ReactNode;
+    /** Suggestion chips / context strip above everything. */
+    suggestions?: React.ReactNode;
+    /** Drag-drop + paste wiring for file attachments. */
+    onAttachFiles?: (files: File[]) => void;
+    labels?: Partial<ChatComposerLabels>;
+    icons?: Partial<ChatComposerIcons>;
+    textareaRef?: React.Ref<HTMLTextAreaElement>;
+    className?: string;
+}
+/**
+ * The family chat input: auto-growing IME-safe textarea, send/stop
+ * states, attachment/dictation/toolbar slots, drag-drop + paste file
+ * wiring. Presentational + controlled; transports stay app-side.
+ */
+declare const ChatComposer: React.ForwardRefExoticComponent<ChatComposerProps & React.RefAttributes<HTMLFormElement>>;
+
+interface ChatTranscriptLabels {
+    log: string;
+    scrollToBottom: string;
+    empty: string;
+    replied: string;
+}
+interface ChatTranscriptProps {
+    items: ChatMessageView[];
+    /** Override the default `ChatMessage` + `MarkdownSurface` rendering. */
+    renderItem?: (message: ChatMessageView, index: number) => React.ReactNode;
+    /** Streaming tail — the live turn bubble (or any node). */
+    live?: React.ReactNode;
+    emptyState?: React.ReactNode;
+    /** Stick to bottom while the user hasn't scrolled away. Default true. */
+    autoScroll?: boolean;
+    /** Distance from the bottom that still counts as "at the bottom". Default 120 px. */
+    scrollThresholdPx?: number;
+    /** Virtualize long transcripts (dynamic row measurement). Default false. */
+    virtualized?: boolean;
+    labels?: Partial<ChatTranscriptLabels>;
+    className?: string;
+}
+/**
+ * The conversation list: `role="log"` with polite turn-completion
+ * announcements, stick-to-bottom auto-scroll with a jump-to-latest pill,
+ * optional virtualization for thousand-message threads.
+ */
+declare const ChatTranscript: React.ForwardRefExoticComponent<ChatTranscriptProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatBranchTreeIcons {
+    user: LucideIcon;
+    assistant: LucideIcon;
+    fork: LucideIcon;
+}
+interface ChatBranchTreeLabels {
+    tree: string;
+    user: string;
+    assistant: string;
+    forked: (count: number) => string;
+}
+interface ChatBranchTreeNode {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    excerpt?: string;
+    parentId: string | null;
+    activeChildId: string | null;
+    childIds: string[];
+}
+interface ChatBranchTreeProps {
+    /** From `buildBranchTree` / `linearTree` (chat-core). */
+    tree: BranchTree;
+    /** Override the pointer-walk active set (e.g. while a select is pending). */
+    activeIds?: Set<string>;
+    /** Click = flip one pointer (family `select` endpoint, level-flip semantics). */
+    onSelect?: (nodeId: string) => void;
+    maxExcerpt?: number;
+    icons?: Partial<ChatBranchTreeIcons>;
+    labels?: Partial<ChatBranchTreeLabels>;
+    className?: string;
+}
+/**
+ * The OpenWebUI-style conversation tree rail (study's `BranchTreePanel`,
+ * family branching contract): recursive commit-graph rows — filled dots on
+ * the active path, hollow dots for hidden variants, fork badges, excerpts.
+ * `role="tree"` with roving-tabindex keyboard navigation.
+ */
+declare const ChatBranchTree: React.ForwardRefExoticComponent<ChatBranchTreeProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatSessionView {
+    id: string;
+    title: string;
+    updatedAt?: string | number | Date;
+    meta?: Record<string, unknown>;
+}
+interface ChatSessionListLabels {
+    search: string;
+    searchPlaceholder: string;
+    newChat: string;
+    rename: string;
+    delete: string;
+    export: string;
+    today: string;
+    yesterday: string;
+    earlier: string;
+    empty: string;
+    noResults: string;
+}
+interface ChatSessionListIcons {
+    newChat: LucideIcon;
+    rename: LucideIcon;
+    delete: LucideIcon;
+    export: LucideIcon;
+}
+interface ChatSessionListProps {
+    sessions: ChatSessionView[];
+    activeId?: string | null;
+    onSelect: (id: string) => void;
+    onNew?: () => void;
+    onRename?: (id: string) => void;
+    onDelete?: (id: string) => void;
+    onExport?: (id: string) => void;
+    searchable?: boolean;
+    groupByDate?: boolean;
+    labels?: Partial<ChatSessionListLabels>;
+    icons?: Partial<ChatSessionListIcons>;
+    className?: string;
+}
+/**
+ * The session list beside a full-page chat (study's `ChatSessionList` +
+ * health's history overlay, generalized): fuzzy search, date grouping,
+ * active marking, per-session actions (rename/delete/export) via the
+ * menu when handlers are provided. All actions stay app-side.
+ */
+declare const ChatSessionList: React.ForwardRefExoticComponent<ChatSessionListProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatToolCatalogArgument {
+    name: string;
+    type?: string;
+    required?: boolean;
+    description?: string | null;
+}
+interface ChatToolCatalogEntry {
+    /** Stable tool identifier (rendered mono). */
+    name: string;
+    /** Human title; falls back to `name`. */
+    title?: string;
+    description?: string;
+    arguments?: ChatToolCatalogArgument[];
+    example?: string | null;
+    response?: string | null;
+    scope?: string | null;
+}
+interface ChatToolsCatalogLabels {
+    /** Accessible name of the tool list. */
+    tools: string;
+    search: string;
+    searchPlaceholder: string;
+    arguments: string;
+    response: string;
+    required: string;
+    optional: string;
+    empty: string;
+    noResults: string;
+}
+interface ChatToolsCatalogProps {
+    tools: ChatToolCatalogEntry[];
+    searchable?: boolean;
+    /** Expand every entry's details initially (uncontrolled per entry after that). */
+    defaultOpen?: boolean;
+    labels?: Partial<ChatToolsCatalogLabels>;
+    icon?: LucideIcon;
+    className?: string;
+}
+/**
+ * Catalog of the tools an assistant can use (study's `ToolsDialog` body,
+ * generalized): searchable disclosure cards with description, argument
+ * list, example and response shape. Presentational only — fetching and
+ * the surrounding modal/popover stay app-side.
+ */
+declare const ChatToolsCatalog: React.ForwardRefExoticComponent<ChatToolsCatalogProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatExportMessage {
+    role: string;
+    content: string;
+}
+interface ChatExportOptions {
+    /** Role label for user messages. Default `You`. */
+    userLabel?: string;
+    /** Role label for assistant messages. Default `Assistant`. */
+    assistantLabel?: string;
+    /** `bold` renders `**You:**` (career style); `heading` renders `### 🙋 Question` (study style). */
+    roleStyle?: 'bold' | 'heading';
+    /**
+     * Per-message annotation lines rendered as blockquotes directly after
+     * the content (career: referenced jobs/postings; study: citations).
+     */
+    annotations?: (message: ChatExportMessage, index: number) => string[];
+}
+/**
+ * Conversation → Markdown builder (career's `buildChatMarkdown` + study's
+ * `messagesToMarkdown`, generalized): title header, one labelled section
+ * per message, app-supplied blockquote annotations. Pure — no DOM.
+ */
+declare function buildChatMarkdown(title: string, messages: ChatExportMessage[], options?: ChatExportOptions): string;
+/** Slugged `.md` file name for a chat title (`My Chat!` → `my-chat.md`). */
+declare function chatExportFileName(title: string): string;
+/** Client-side download of the built markdown (blob + object URL). */
+declare function downloadChatMarkdown(markdown: string, fileName: string): void;
+
+interface ChatHistoryButtonLabels {
+    open: string;
+}
+interface ChatHistoryButtonProps {
+    /**
+     * Popover content, typically the app's session-list glue. Called with
+     * `close` — invoke it after a pick to dismiss the popover (the
+     * `closeSignal` pattern underneath).
+     */
+    children: (close: () => void) => React.ReactNode;
+    icon?: LucideIcon;
+    /** Called every time the popover opens — refresh the session list here. */
+    onOpen?: () => void;
+    align?: 'start' | 'center' | 'end';
+    panelClassName?: string;
+    labels?: Partial<ChatHistoryButtonLabels>;
+    className?: string;
+}
+/**
+ * Header entry point for a chat's session history (career's
+ * `HistoryButton` + study's ChatPanel history popover, generalized): a
+ * labelled popover trigger wrapping the app's session list. The list
+ * itself (search, actions) stays app-side via
+ * [`ChatSessionList`](../chat-session-list) glue.
+ */
+declare function ChatHistoryButton({ children, icon: Icon, onOpen, align, panelClassName, labels, className, }: ChatHistoryButtonProps): React.JSX.Element;
+
+interface ChatTraceMetaProps {
+    /** Model identifier that produced the reply. */
+    model?: string;
+    /** Turn elapsed time (formatted ms below 1 s, then seconds). */
+    durationMs?: number;
+    /** Number of tools the turn executed (renders `N tools`). */
+    toolCount?: number;
+    className?: string;
+}
+/**
+ * Compact turn-trace badges ("gpt-5.6 · 1.9 s · 3 tools", career's
+ * `TraceMeta`, generalized): renders nothing without data. Reads a
+ * normalized view-model — parsing `metadata_json` stays app-side.
+ */
+declare const ChatTraceMeta: React.ForwardRefExoticComponent<ChatTraceMetaProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatTraceTimelineEntry {
+    /** `phase` = model/flow round (primary bar); `tool` = tool call (warning bar). */
+    kind: 'phase' | 'tool';
+    /** Phase label or tool name (translated at the call site). */
+    label: string;
+    /** Secondary detail, e.g. the tool arguments summary (title tooltip). */
+    detail?: string | null;
+    startMs?: number | null;
+    durationMs?: number | null;
+    /** Outcome of a tool execution (`tool` rows); renders a status dot. */
+    status?: 'ok' | 'error' | null;
+    /** Pretty-printed call arguments (expandable block on `tool` rows). */
+    args?: string | null;
+    /** Tool response text (expandable block on `tool` rows). */
+    response?: string | null;
+}
+interface ChatTraceTimelineTrace {
+    model?: string | null;
+    /** Total turn latency the bars are proportional to. */
+    latencyMs?: number | null;
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+    /** Raw model reasoning, shown in a nested disclosure. */
+    thinking?: string | null;
+}
+interface ChatTraceTimelineLabels {
+    /** Accessible name of the toggle (summary is composed from data). */
+    toggle: string;
+    /** Word appended to the tool count, e.g. `tools`. */
+    tools: string;
+    /** Prefix of the expanded total row, e.g. `Total`. */
+    total: string;
+    /** Suffix of the token count, e.g. `tokens`. */
+    tokens: string;
+    reasoning: string;
+    /** Header of the expandable arguments block. */
+    arguments: string;
+    /** Header of the expandable response block. */
+    response: string;
+    /** Accessible name of a tool row's detail disclosure. */
+    details: string;
+}
+interface ChatTraceTimelineProps {
+    trace: ChatTraceTimelineTrace;
+    entries: ChatTraceTimelineEntry[];
+    defaultOpen?: boolean;
+    labels?: Partial<ChatTraceTimelineLabels>;
+    className?: string;
+}
+/**
+ * Collapsible per-turn trace timeline (study's `TraceTimeline`,
+ * generalized): collapsed summary (duration · N tools · model), expanded
+ * duration-proportional bar rows for flow phases and tool calls plus a
+ * raw-reasoning disclosure. Presentational — persisted or live trace data
+ * is mapped to `entries` app-side.
+ */
+declare const ChatTraceTimeline: React.ForwardRefExoticComponent<ChatTraceTimelineProps & React.RefAttributes<HTMLDivElement>>;
+
+type ChatPanelVariant = 'page' | 'sidebar' | 'bubble';
+interface ChatPanelProps {
+    /** Layout tier: full page (full-bleed shell, centered conversation column), sidebar (dense column), bubble (compact widget body). */
+    variant: ChatPanelVariant;
+    /** Header row: title node + action nodes (session list, branch tree, expand, close). */
+    title?: React.ReactNode;
+    actions?: React.ReactNode;
+    /** Status strip under the header (connection warnings, context summary). */
+    banner?: React.ReactNode;
+    /** Usually `<ChatTranscript …/>`. */
+    transcript: React.ReactNode;
+    /** Usually `<ChatComposer …/>`. */
+    composer?: React.ReactNode;
+    /** Disclaimer row under the composer (health guidance, etc.). */
+    footer?: React.ReactNode;
+    className?: string;
+}
+/**
+ * The composed chat host — the one uniform surface assembly behind the
+ * family's three shapes (full page / sidepanel / bubble). Owns layout
+ * only; transcript, composer and every feature slot stay app-composed
+ * (ADR-006 tier 3, `RichTextEditor` precedent).
+ */
+declare const ChatPanel: React.ForwardRefExoticComponent<ChatPanelProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatDrawerProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The sidepanel content — usually `ChatPanel variant="sidebar"`. */
+    panel: React.ReactNode;
+    side?: 'right' | 'left';
+    /** Controlled width in px (persist app-side). Default 480. */
+    width?: number;
+    onWidthChange?: (width: number) => void;
+    minWidth?: number;
+    maxWidth?: number;
+    resizable?: boolean;
+    closeLabel?: string;
+    resizeLabel?: string;
+    /** Accessible dialog name (visually hidden). Default "Chat". */
+    title?: string;
+    /** Below this viewport width the drawer goes full-screen. Default 768. */
+    fullScreenBreakpointPx?: number;
+    container?: HTMLElement | null;
+    overlayClassName?: string;
+    className?: string;
+}
+/**
+ * The resizable chat sidepanel (health's `AIDrawer` + study's resizable
+ * sidebar, family-standard): portal overlay on Radix Dialog (focus trap,
+ * Escape), drag + keyboard resize, full-screen below the breakpoint.
+ */
+declare const ChatDrawer: React.ForwardRefExoticComponent<ChatDrawerProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ChatLauncherProps {
+    /** The anchored panel body — usually `ChatPanel variant="bubble"`. */
+    panel: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    position?: 'bottom-right' | 'bottom-left';
+    label?: string;
+    closeLabel?: string;
+    icon?: LucideIcon;
+    closeIcon?: LucideIcon;
+    /** Unread / activity badge. */
+    badge?: number | string;
+    container?: HTMLElement | null;
+    panelClassName?: string;
+    className?: string;
+}
+/**
+ * The floating chat bubble (career's `ChatWidget` launcher,
+ * family-standard): fixed launcher button opening an anchored, non-modal
+ * panel. `aria-expanded` wiring, Escape closes while focus is inside.
+ */
+declare const ChatLauncher: React.ForwardRefExoticComponent<ChatLauncherProps & React.RefAttributes<HTMLButtonElement>>;
+
+export { AboutCard, type AboutCardProps, type AboutCreator, AboutFooterLine, type AboutFooterLineProps, type AboutLicense, type AboutLinkItem, AboutLinkList, type AboutLinkListProps, AboutNote, type AboutNoteContent, type AboutNoteProps, AboutPanel, type AboutPanelProps, type AboutSponsorContent, ActionMenu, type ActionMenuItem, type ActionMenuProps, type AiAction, AiActionsDropdown, type AiActionsDropdownProps, AiButton, type AiButtonProps, AiMagicFill, type AiMagicFillProps, type AiTextTransformEventHandlers, type AiTextTransformStatus, type AiTextTransformTransport, Badge, type BadgeProps, type BranchNode, type BranchNodeInput, type BranchTree, type BreadcrumbItem, type BreadcrumbLinkProps, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, CapabilityChips, type CapabilityChipsProps, type CapabilityDescriptor, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, CareerMark, type ChatAttachmentView, ChatBranchTree, type ChatBranchTreeIcons, type ChatBranchTreeLabels, type ChatBranchTreeNode, type ChatBranchTreeProps, ChatComposer, type ChatComposerIcons, type ChatComposerLabels, type ChatComposerProps, ChatDrawer, type ChatDrawerProps, type ChatError, type ChatExportMessage, type ChatExportOptions, ChatHistoryButton, type ChatHistoryButtonLabels, type ChatHistoryButtonProps, ChatLauncher, type ChatLauncherProps, ChatMessage, type ChatMessageAction, type ChatMessageActions, ChatMessageEditor, type ChatMessageEditorLabels, type ChatMessageEditorProps, type ChatMessageLabels, type ChatMessageProps, type ChatMessageStatus, type ChatMessageVariants, type ChatMessageView, ChatPanel, type ChatPanelProps, type ChatPanelVariant, ChatReasoning, type ChatReasoningLabels, type ChatReasoningProps, type ChatRole, ChatSessionList, type ChatSessionListIcons, type ChatSessionListLabels, type ChatSessionListProps, type ChatSessionView, type ChatStreamEvent, type ChatStreamTransport, ChatToolCard, type ChatToolCardLabels, type ChatToolCardProps, type ChatToolCatalogArgument, type ChatToolCatalogEntry, ChatToolsCatalog, type ChatToolsCatalogLabels, type ChatToolsCatalogProps, ChatTraceMeta, type ChatTraceMetaProps, ChatTraceTimeline, type ChatTraceTimelineEntry, type ChatTraceTimelineLabels, type ChatTraceTimelineProps, type ChatTraceTimelineTrace, ChatTranscript, type ChatTranscriptLabels, type ChatTranscriptProps, ChatTurnStatus, type ChatTurnStatusLabels, type ChatTurnStatusProps, CheckIndicator, type CheckIndicatorProps, ChipInput, type ChipInputProps, ChipList, type ChipListProps, type ChipVariant, Combobox, ComboboxMulti, type ComboboxMultiProps, type ComboboxOption, type ComboboxProps, ConfirmationModal, type ConfirmationModalProps, ConnectionTestRow, type ConnectionTestRowProps, type ConnectionTestStatus, ContextMenu, type ContextMenuItem, type ContextMenuProps, CopyButton, type CopyButtonProps, DatePicker, type DatePickerProps, DictationButton, type DictationButtonProps, type DictationError, type DictationResult, type DictationStatus, DictationStrip, type DictationStripLabels, type DictationStripProps, type DiffCell, type DiffRow, type DiffSegment, EmptyState, type EmptyStateProps, ErrorBanner, type ErrorBannerProps, ExpandableSearch, type ExpandableSearchProps, type FamilyApp, FamilyBadge, type FamilyBadgeProps, type FamilyCreator, type FamilyMember, FieldLabel, type FieldLabelProps, FileCard, type FileCardProps, type FileCardStatus, FileQueue, type FileQueueItem, type FileQueueProps, type FlowError, FlowStatusCard, type FlowStatusCardProps, type FlowStep, type FlowStepInfo, type FlowStepStatus, FormModal, type FormModalProps, HealthMark, InfoButton, type InfoButtonProps, InfoTooltip, type InfoTooltipProps, Input, type InputProps, type LineDiffOptions, type LineDiffResult, type LiveNodeState, type LiveToolCall, type LiveTurnAction, type LiveTurnState, type LiveTurnStatus, type LogoProps, type LogoTheme, MarkdownCodeBlock, type MarkdownCodeBlockLabels, type MarkdownCodeBlockProps, type MarkdownComponents, MarkdownSurface, type MarkdownSurfaceProps, MarqueeBand, type MarqueePhase, type MarqueeSelection, MarqueeSurface, type MarqueeSurfaceProps, Menu, MenuCheckboxItem, type MenuCheckboxItemProps, MenuContent, MenuGroup, MenuItem, type MenuItemProps, MenuLabel, MenuSeparator, MenuTrigger, MermaidDiagram, type MermaidDiagramProps, MessageVariantSwitcher, type MessageVariantSwitcherLabels, type MessageVariantSwitcherProps, Modal, ModalClose, ModalContent, type ModalContentProps, ModalDescription, ModalFooter, ModalHeader, ModalTitle, ModalTrigger, ModelPicker, type ModelPickerModel, type ModelPickerProps, type ModelPickerProvider, ModelRegistry, type ModelRegistryDraft, type ModelRegistryModel, type ModelRegistryPatch, type ModelRegistryProps, type ModelRegistryProvider, type ModelRegistryRemoteModel, type ModelRegistryRemoteState, type NavChild, type NavItem, NeuronectionMark, NeuronectionWordmark, type NeuronectionWordmarkProps, PanelModal, type PanelModalProps, Popover, PopoverAnchor, PopoverButton, type PopoverButtonProps, PopoverClose, PopoverContent, PopoverTrigger, Portal, type PortalProps, ProviderForm, type ProviderFormProps, RangeBar, type RangeBarProps, type Rect, RichTextEditor, type RichTextEditorIcons, type RichTextEditorLabels, type RichTextEditorProps, type RichTextToolbarGroup, ScaleSlider, type ScaleSliderProps, SearchInput, type SearchInputProps, SelectionBar, type SelectionBarProps, type SettingsNavItem, SettingsShell, type SettingsShellProps, SidebarNav, type SidebarNavLabels, type SidebarNavProps, Spinner, type SpinnerProps, SponsorCard, type SponsorCardProps, type SponsorChannel, Stepper, type StepperProps, type StepperStep, StudyMark, Table, type TableProps, TaskAssignmentPicker, type TaskAssignmentPickerProps, type TaskAssignmentSection, type TaskAssignmentTask, TechChips, type TechChipsProps, TextDiffView, type TextDiffViewLabels, type TextDiffViewProps, ThemeScope, type ThemeScopeProps, ThemeTokens, TimeList, type TimeListProps, TimePicker, TimePickerContent, type TimePickerContentProps, type TimePickerProps, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, UndoNotice, type UndoNoticeProps, UploadDropzone, type UploadDropzoneProps, type UseAiTextTransformOptions, type UseChatStreamOptions, type UseChatStreamResult, type UseDictationOptions, type UseMarqueeOptions, UserMenu, type UserMenuItem, type UserMenuProps, ViewToggle, type ViewToggleProps, type ViewToggleView, Wizard, type WizardContext, type WizardProps, type WizardStep, activePathSet, badgeVariants, buildBranchTree, buildChatMarkdown, buttonVariants, chatExportFileName, cn, computeLineDiff, downloadChatMarkdown, formatBytes, hitTestIds, initialLiveTurnState, linearTree, liveTurnReducer, marqueeRect, modalContentVariants, rectsIntersect, scaleColorForValue, useAiTextTransform, useChatStream, useDictation, useLogoId, useMarquee, variantInfo, walkActivePath, wordSegments };