@discuss-ds/ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,876 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { Switch as Switch$1, Toggle as Toggle$1, Checkbox as Checkbox$1, ToggleGroup, Slot, Label as Label$1, RadioGroup as RadioGroup$1, Select as Select$1, Slider as Slider$1, Tabs as Tabs$1, Dialog as Dialog$1, DropdownMenu as DropdownMenu$1, Toast as Toast$1, Tooltip as Tooltip$1, Progress as Progress$1 } from 'radix-ui';
+import { DayPickerProps } from 'react-day-picker';
+import * as react_hook_form from 'react-hook-form';
+import { FieldValues, FieldPath, ControllerProps } from 'react-hook-form';
+import { IconProps } from '@phosphor-icons/react';
+
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "subtle" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "md" | "sm" | "lg" | "icon" | "icon-sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    /**
+     * Render `props.children` into the child element instead of wrapping it in
+     * a `<button>` (Radix `Slot`) — lets consumers compose e.g.
+     * `<Button asChild><a href="...">Label</a></Button>` without double-wrapping.
+     * The ref then targets whatever element the child renders, not necessarily
+     * an `HTMLButtonElement`.
+     */
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+type SwitchProps = React.ComponentPropsWithoutRef<typeof Switch$1.Root>;
+declare const Switch: React.ForwardRefExoticComponent<Omit<Switch$1.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+type ToggleProps = React.ComponentPropsWithoutRef<typeof Toggle$1.Root>;
+declare const Toggle: React.ForwardRefExoticComponent<Omit<Toggle$1.ToggleProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+type AIStatus = 'idle' | 'thinking' | 'executing' | 'working';
+interface AIMiniAvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** `idle` shows only the mark; the others add a status line next to it. */
+    status?: AIStatus;
+    /** Override the status text. */
+    label?: React.ReactNode;
+    /** Elapsed time shown after the label while `working` (e.g. "45 s"). */
+    elapsed?: React.ReactNode;
+}
+declare const AIMiniAvatar: React.ForwardRefExoticComponent<AIMiniAvatarProps & React.RefAttributes<HTMLDivElement>>;
+
+interface AIResponseContainerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Display-font heading at the top of the reply (e.g. "Confirm new project."). */
+    title?: React.ReactNode;
+    /** Message actions row — a `Timestamp` with copy / like / dislike / retry buttons. */
+    actions?: React.ReactNode;
+    /** Status line under the reply — an `AIMiniAvatar`. */
+    feedback?: React.ReactNode;
+}
+declare const AIResponseContainer: React.ForwardRefExoticComponent<AIResponseContainerProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const askAiToggleVariants: (props?: ({
+    type?: "menu" | "action" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AskAiToggleProps extends Omit<React.ComponentPropsWithoutRef<typeof Toggle$1.Root>, 'type'>, VariantProps<typeof askAiToggleVariants> {
+}
+declare const AskAiToggle: React.ForwardRefExoticComponent<AskAiToggleProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface ChatChoicesProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** The question the assistant is asking. */
+    title: React.ReactNode;
+}
+declare const ChatChoices: React.ForwardRefExoticComponent<ChatChoicesProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatOptionBaseProps {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    className?: string;
+}
+interface ChatOptionActionProps extends ChatOptionBaseProps, Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'title'> {
+    kind?: 'action';
+}
+interface ChatOptionRadioProps extends ChatOptionBaseProps {
+    kind: 'radio';
+    /** Value in the surrounding `RadioGroup`. */
+    value: string;
+    disabled?: boolean;
+}
+interface ChatOptionCheckboxProps extends ChatOptionBaseProps {
+    kind: 'checkbox';
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+}
+type ChatOptionProps = ChatOptionActionProps | ChatOptionRadioProps | ChatOptionCheckboxProps;
+declare function ChatOption(props: ChatOptionProps): React.JSX.Element;
+
+interface ChatInputProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSubmit' | 'defaultValue' | 'onChange'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Called with the text when the send button (or Enter) is pressed. */
+    onSubmit?: (value: string) => void;
+    placeholder?: string;
+    /** Accessible name for the text area. */
+    'aria-label'?: string;
+    /** Attached files (`FileAttachment`s) shown above the text. */
+    attachments?: React.ReactNode;
+    /** A `ChatChoices` block shown above the text area. */
+    choices?: React.ReactNode;
+    /** Slot before the send button — usually a `ProjectSelector`. */
+    trailing?: React.ReactNode;
+    /** Called when the add (+) button is pressed. Hides the button when omitted. */
+    onAdd?: () => void;
+    addLabel?: string;
+    sendLabel?: string;
+    disabled?: boolean;
+}
+declare const ChatInput: React.ForwardRefExoticComponent<ChatInputProps & React.RefAttributes<HTMLDivElement>>;
+interface AskAiInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onSubmit'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    sendLabel?: string;
+}
+declare const AskAiInput: React.ForwardRefExoticComponent<AskAiInputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FileAttachmentProps extends React.HTMLAttributes<HTMLDivElement> {
+    name: string;
+    /** File type badge text, e.g. "PDF". */
+    type?: string;
+    /** Shows the round remove button on hover or keyboard focus (Figma: Default). Omit for the sent-message card (Figma: Variant 3). */
+    onRemove?: () => void;
+    removeLabel?: string;
+}
+declare const FileAttachment: React.ForwardRefExoticComponent<FileAttachmentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ProjectSelectorProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'defaultValue'> {
+    /** Name of the chosen project. Leave empty for "New Project". */
+    project?: string;
+    /**
+     * Existing project names. When given, pressing the selector opens a menu with
+     * "New Project" and these names; the current choice is checked.
+     */
+    projects?: string[];
+    /** Called with the chosen project name, or `undefined` for "New Project". */
+    onProjectChange?: (project: string | undefined) => void;
+    /** Label of the "new project" menu item and of the pill when no project is chosen. */
+    newProjectLabel?: string;
+    /**
+     * `selected` means the project is locked for this chat: the pill is read-only
+     * (no caret, neutral border). Otherwise it is a trigger with a caret.
+     */
+    selected?: boolean;
+}
+declare const ProjectSelector: React.ForwardRefExoticComponent<ProjectSelectorProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface TimestampProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The time text, e.g. "5 minutes ago". */
+    time: React.ReactNode;
+    /** Action buttons (ghost icon `Button`s) shown next to the time. */
+    children?: React.ReactNode;
+    /** `before` puts the time left of the actions (user messages); `after` puts it right of them (AI replies). */
+    timePosition?: 'before' | 'after';
+}
+declare const Timestamp: React.ForwardRefExoticComponent<TimestampProps & React.RefAttributes<HTMLDivElement>>;
+
+interface TopicCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Leading 24px icon (a Phosphor icon, e.g. `<FolderOpen weight="fill" />`). */
+    icon?: React.ReactNode;
+    title: React.ReactNode;
+    /** Small tag beside the title (e.g. a language `RoleTag`). */
+    badge?: React.ReactNode;
+    description: React.ReactNode;
+    /** Chips under the description (e.g. topic tags). */
+    tags?: React.ReactNode;
+    /** Meta line under the description (e.g. "7 Questions · 30 minutes"). */
+    meta?: React.ReactNode;
+}
+declare const TopicCard: React.ForwardRefExoticComponent<TopicCardProps & React.RefAttributes<HTMLDivElement>>;
+interface TopicCardMetaItemProps extends React.HTMLAttributes<HTMLSpanElement> {
+    icon: React.ReactNode;
+}
+/** An icon + text item for `TopicCard`'s `meta` line. */
+declare function TopicCardMetaItem({ icon, children, className, ...props }: TopicCardMetaItemProps): React.JSX.Element;
+/** A short chip for `TopicCard`'s `tags` row. */
+declare function TopicCardTag({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+interface TopicActivityRowProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'title'> {
+    /** Status text, e.g. "New Activity Created". */
+    status: React.ReactNode;
+}
+declare const TopicActivityRow: React.ForwardRefExoticComponent<TopicActivityRowProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface UserMessageBubbleProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Attached files (`FileAttachment`s) shown above the text. */
+    attachments?: React.ReactNode;
+    /** Row under the bubble, usually a `Timestamp` with message actions. */
+    footer?: React.ReactNode;
+}
+declare const UserMessageBubble: React.ForwardRefExoticComponent<UserMessageBubbleProps & React.RefAttributes<HTMLDivElement>>;
+
+type CalendarProps = DayPickerProps & {
+    /** Days to mark with a dashed outline (e.g. suggested interview slots). */
+    recommendedDates?: Date[];
+};
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, recommendedDates, modifiers, modifiersClassNames, startMonth, endMonth, ...props }: CalendarProps): React.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+
+type CheckboxProps = React.ComponentPropsWithoutRef<typeof Checkbox$1.Root>;
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<Checkbox$1.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+interface CheckboxFieldProps extends CheckboxProps {
+    label: React.ReactNode;
+    /** Secondary line under the label. */
+    description?: React.ReactNode;
+}
+/** Checkbox with its label (and optional description) laid out per Figma. */
+declare const CheckboxField: React.ForwardRefExoticComponent<CheckboxFieldProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface TimeValue {
+    /** 1–12 */
+    hour: number;
+    /** 0–59 */
+    minute: number;
+    period: 'AM' | 'PM';
+}
+interface TimeItemProps extends React.ComponentPropsWithoutRef<typeof ToggleGroup.Item> {
+    /** Dashed outline to suggest this slot. */
+    recommended?: boolean;
+}
+declare const TimeItem: React.ForwardRefExoticComponent<TimeItemProps & React.RefAttributes<HTMLButtonElement>>;
+interface TimePickerProps {
+    value?: TimeValue;
+    onValueChange?: (value: TimeValue) => void;
+    /** Minute interval between options. */
+    minuteStep?: number;
+    isHourDisabled?: (hour: number, period: 'AM' | 'PM') => boolean;
+    isMinuteDisabled?: (minute: number, hour: number, period: 'AM' | 'PM') => boolean;
+    isHourRecommended?: (hour: number, period: 'AM' | 'PM') => boolean;
+    isMinuteRecommended?: (minute: number, hour: number, period: 'AM' | 'PM') => boolean;
+    className?: string;
+}
+/** Figma: Calendar (25) › Time Picker Panel — AM/PM switch with hour and minute columns. */
+declare function TimePicker({ value, onValueChange, minuteStep, isHourDisabled, isMinuteDisabled, isHourRecommended, isMinuteRecommended, className, }: TimePickerProps): React.JSX.Element;
+
+interface DateTimePickerProps {
+    /** Initial selection. The picker keeps its own draft until Apply, so remount it (e.g. with a `key`) to reset from a new value. */
+    value?: Date;
+    defaultValue?: Date;
+    /** Called with the chosen date (time included when `showTime`) when Apply is pressed. */
+    onApply?: (value: Date | undefined) => void;
+    onReset?: () => void;
+    /** Show the time picker column next to the calendar. */
+    showTime?: boolean;
+    calendarProps?: Omit<CalendarProps, 'mode' | 'selected' | 'onSelect'>;
+    timePickerProps?: Omit<TimePickerProps, 'value' | 'onValueChange'>;
+    className?: string;
+}
+declare function DateTimePicker({ value, defaultValue, onApply, onReset, showTime, calendarProps, timePickerProps, className, }: DateTimePickerProps): React.JSX.Element;
+interface DatePickerProps extends Omit<DateTimePickerProps, 'onApply' | 'className'> {
+    label?: React.ReactNode;
+    placeholder?: string;
+    onValueChange?: (value: Date | undefined) => void;
+    className?: string;
+}
+/** Field-style trigger that opens a `DateTimePicker` in a popover. Figma: Calendar (25) › Calendar & time. */
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLButtonElement>>;
+
+type FieldStatus = 'default' | 'success' | 'error';
+/**
+ * Classes for a bordered field surface (Figma: Text Input / Textarea / Select).
+ * Hover and the open "select" state use `input-accent`; success and error swap
+ * the border colour. Focus is handled by the global `:focus-visible` ring.
+ */
+declare function fieldSurfaceClasses(status?: FieldStatus): string;
+interface FieldControlProps {
+    id: string;
+    'aria-describedby'?: string;
+    'aria-invalid'?: true;
+}
+interface FieldProps {
+    /** Label shown above the control. */
+    label?: React.ReactNode;
+    /** Neutral helper text shown under the control. Replaced by `message` on success/error. */
+    description?: React.ReactNode;
+    /** Status message shown with an icon when `status` is `success` or `error`. */
+    message?: React.ReactNode;
+    status?: FieldStatus;
+    /** Id for the control; generated when omitted. */
+    id?: string;
+    className?: string;
+    /** Render the control, spreading the supplied props onto it. */
+    children: (control: FieldControlProps) => React.ReactNode;
+}
+/**
+ * Label + control + helper/status message, wired together with
+ * `htmlFor`/`aria-describedby`/`aria-invalid`. Shared by Text Input, Textarea,
+ * Select, Numerical input and Input with action.
+ */
+declare function Field({ label, description, message, status, id, className, children }: FieldProps): React.JSX.Element;
+
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getErrors, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, resetDefaultValues, handleSubmit, unregister, control, register, setFocus, subscribe, }: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare function FormField<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>(props: ControllerProps<TFieldValues, TName>): React.JSX.Element;
+declare function useFormField(): {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: react_hook_form.FieldError | undefined;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+type FormItemProps = React.HTMLAttributes<HTMLDivElement>;
+declare const FormItem: React.ForwardRefExoticComponent<FormItemProps & React.RefAttributes<HTMLDivElement>>;
+type FormLabelProps = React.LabelHTMLAttributes<HTMLLabelElement>;
+declare const FormLabel: React.ForwardRefExoticComponent<FormLabelProps & React.RefAttributes<HTMLLabelElement>>;
+type FormControlProps = React.ComponentPropsWithoutRef<typeof Slot.Root>;
+declare const FormControl: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLElement> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+type FormDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare const FormDescription: React.ForwardRefExoticComponent<FormDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+type FormMessageProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare const FormMessage: React.ForwardRefExoticComponent<FormMessageProps & React.RefAttributes<HTMLParagraphElement>>;
+
+/** `September 23, 2026 - 11:30 AM` (or just the date when `showTime` is false). */
+declare function formatDateTime(date: Date, showTime?: boolean): string;
+
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** Border/message state. `error` also sets `aria-invalid`. */
+    status?: FieldStatus;
+    /** Convenience: renders a Field (label + helper/status message) around the input. */
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    message?: React.ReactNode;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface InputWithActionProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** Label of the trailing action button. */
+    actionLabel: string;
+    onAction?: React.MouseEventHandler<HTMLButtonElement>;
+    /** Chips (e.g. `EditableTag`s) shown inside the field before the input. */
+    tags?: React.ReactNode;
+    status?: Exclude<FieldStatus, 'success'>;
+    label?: React.ReactNode;
+    /** Support text shown under the field. */
+    description?: React.ReactNode;
+    /** Error message shown when `status` is `error`. */
+    message?: React.ReactNode;
+}
+declare const InputWithAction: React.ForwardRefExoticComponent<InputWithActionProps & React.RefAttributes<HTMLInputElement>>;
+
+type LabelProps = React.ComponentPropsWithoutRef<typeof Label$1.Root>;
+declare const Label: React.ForwardRefExoticComponent<Omit<Label$1.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;
+
+interface NumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange' | 'type' | 'size'> {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Unit shown after the value (e.g. "minutes"). */
+    unit?: string;
+    status?: FieldStatus;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    message?: React.ReactNode;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
+
+type RadioGroupProps = React.ComponentPropsWithoutRef<typeof RadioGroup$1.Root>;
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroup$1.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type RadioGroupItemProps = React.ComponentPropsWithoutRef<typeof RadioGroup$1.Item>;
+declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroup$1.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+interface RadioGroupFieldItemProps extends RadioGroupItemProps {
+    label: React.ReactNode;
+    /** Secondary line under the label. */
+    description?: React.ReactNode;
+}
+/** A radio with its label (and optional description) laid out per Figma. */
+declare const RadioGroupFieldItem: React.ForwardRefExoticComponent<RadioGroupFieldItemProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface SearchBarProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Called when the clear (×) button is pressed, after the field has been emptied. */
+    onClear?: () => void;
+    /** Label for the clear button. */
+    clearLabel?: string;
+}
+declare const SearchBar: React.ForwardRefExoticComponent<SearchBarProps & React.RefAttributes<HTMLInputElement>>;
+
+declare const Select: React.FC<Select$1.SelectProps>;
+declare const SelectValue: React.ForwardRefExoticComponent<Select$1.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectGroup: React.ForwardRefExoticComponent<Select$1.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+interface SelectTriggerProps extends React.ComponentPropsWithoutRef<typeof Select$1.Trigger> {
+    /** Leading icon (Figma: "With label = No" shows a gear). */
+    icon?: React.ReactNode;
+}
+declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+type SelectContentProps = React.ComponentPropsWithoutRef<typeof Select$1.Content>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<Select$1.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type SelectItemProps = React.ComponentPropsWithoutRef<typeof Select$1.Item>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<Select$1.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface SliderProps extends React.ComponentPropsWithoutRef<typeof Slider$1.Root> {
+    /** Text shown above the track on the left (e.g. "Label"). The max value is shown on the right. */
+    label?: React.ReactNode;
+    /** Show the min and max values above the track instead of a label. */
+    showRange?: boolean;
+    /**
+     * Show the current value in a bubble above the thumb. `true` shows it while
+     * the thumb is hovered, focused or dragged; `'always'` keeps it visible.
+     */
+    showValue?: boolean | 'always';
+}
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    status?: FieldStatus;
+    /** Convenience: renders a Field (label + helper/status message) around the textarea. */
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    message?: React.ReactNode;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+/** `filter` is the pill-shaped table filter; `toggle` is the icon-only mode switch. */
+type TabNavigationVariant = 'filter' | 'toggle';
+declare const TabNavigationContext: React.Context<TabNavigationVariant>;
+declare const tabNavigationVariants: (props?: ({
+    variant?: "filter" | "toggle" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+/** Radix `Tabs.Root` — owns the selected value; pair with `TabNavigation` + `TabItem` + `TabsContent`. */
+declare const Tabs: React.ForwardRefExoticComponent<Tabs$1.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Tabs$1.TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+interface TabNavigationProps extends React.ComponentPropsWithoutRef<typeof Tabs$1.List>, VariantProps<typeof tabNavigationVariants> {
+}
+declare const TabNavigation: React.ForwardRefExoticComponent<TabNavigationProps & React.RefAttributes<HTMLDivElement>>;
+
+type TabItemProps = React.ComponentPropsWithoutRef<typeof Tabs$1.Trigger>;
+declare const TabItem: React.ForwardRefExoticComponent<Omit<Tabs$1.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+
+declare const Dialog: React.FC<Dialog$1.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<Dialog$1.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogClose: React.ForwardRefExoticComponent<Dialog$1.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof Dialog$1.Content> {
+    /** Label for the corner close button. */
+    closeLabel?: string;
+    /** Hide the corner close button (e.g. when the footer is the only way out). */
+    hideClose?: boolean;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<Dialog$1.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<Dialog$1.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+declare const DialogBody: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+declare const DialogFooter: ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+
+declare const DropdownMenu: React.FC<DropdownMenu$1.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenu$1.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenu$1.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenu$1.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSub: React.FC<DropdownMenu$1.DropdownMenuSubProps>;
+type DropdownMenuContentProps = React.ComponentPropsWithoutRef<typeof DropdownMenu$1.Content>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenu$1.Item> {
+    /** Secondary line under the label. */
+    description?: React.ReactNode;
+    /** `destructive` shows a trash icon and red text (Figma: State = Destructive). */
+    variant?: 'default' | 'destructive';
+    /** Leading icon. */
+    icon?: React.ReactNode;
+}
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
+interface DropdownMenuSelectableItemProps {
+    description?: React.ReactNode;
+}
+/** A checkable item: the selected state is accent-coloured with a trailing check (Figma: State = Selected). */
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & DropdownMenuSelectableItemProps & React.RefAttributes<HTMLDivElement>>;
+/** One choice of a `DropdownMenuRadioGroup`, styled like a selected item when active. */
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & DropdownMenuSelectableItemProps & React.RefAttributes<HTMLDivElement>>;
+/** Item that opens a submenu, with a trailing caret (Figma: Expand = Yes). */
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenu$1.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+type ToastVariant = 'info' | 'success' | 'warning' | 'destructive';
+declare const toastVariants: (props?: ({
+    variant?: "destructive" | "success" | "info" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const ToastProvider: React.FC<Toast$1.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<Toast$1.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & React.RefAttributes<HTMLOListElement>>;
+interface ToastProps extends Omit<React.ComponentPropsWithoutRef<typeof Toast$1.Root>, 'title'>, VariantProps<typeof toastVariants> {
+    /** Bold first line. */
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    /** Optional action button (e.g. Undo). Wrap it in `ToastAction`. */
+    action?: React.ReactNode;
+    closeLabel?: string;
+}
+declare const Toast: React.ForwardRefExoticComponent<ToastProps & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Toast$1.ToastActionProps & React.RefAttributes<HTMLButtonElement>>;
+interface ToastInlineProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof toastVariants> {
+    /** Show a close button and call this when it is pressed. */
+    onClose?: () => void;
+    closeLabel?: string;
+}
+declare const ToastInline: React.ForwardRefExoticComponent<ToastInlineProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipProvider: React.FC<Tooltip$1.TooltipProviderProps>;
+declare const Tooltip: React.FC<Tooltip$1.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<Tooltip$1.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+interface TooltipContentProps extends Omit<React.ComponentPropsWithoutRef<typeof Tooltip$1.Content>, 'title'> {
+    /** Bold first line. With `description` this is the Descriptive tooltip. */
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    /** Underlined action line under the description — the Rich tooltip. Usually a link or button. */
+    action?: React.ReactNode;
+    /** Show the pointer arrow toward the trigger. */
+    arrow?: boolean;
+}
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+
+interface FileUploadZoneProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'title' | 'type'> {
+    title?: React.ReactNode;
+    /** Supported formats line. */
+    hint?: React.ReactNode;
+    icon?: React.ReactNode;
+    /** Called with the chosen or dropped files. */
+    onFiles?: (files: File[]) => void;
+}
+declare const FileUploadZone: React.ForwardRefExoticComponent<FileUploadZoneProps & React.RefAttributes<HTMLInputElement>>;
+interface FileUploadItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    name: string;
+    /** File size text, e.g. "443KB". */
+    size?: string;
+    status?: 'uploading' | 'complete' | 'error';
+    /** 0–100, shown while uploading. */
+    progress?: number;
+    /** Remaining time text while uploading, e.g. "2 seconds left". */
+    timeLeft?: string;
+    icon?: React.ReactNode;
+    onRemove?: () => void;
+    removeLabel?: string;
+}
+declare const FileUploadItem: React.ForwardRefExoticComponent<FileUploadItemProps & React.RefAttributes<HTMLDivElement>>;
+
+interface MediaInfoProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    name: string;
+    /** Secondary line parts, e.g. ["443KB", "1/5"], joined with a dot. */
+    details?: string[];
+    onRemove?: () => void;
+    removeLabel?: string;
+    /** Larger name / details (the image preview uses these). */
+    large?: boolean;
+}
+declare function MediaInfo({ name, details, onRemove, removeLabel, large, className, ...props }: MediaInfoProps): React.JSX.Element;
+interface ImagePreviewProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** The image (an `<img>` filling the area). Leave empty for the placeholder fill. */
+    children?: React.ReactNode;
+    name: string;
+    details?: string[];
+    onRemove?: () => void;
+}
+declare const ImagePreview: React.ForwardRefExoticComponent<ImagePreviewProps & React.RefAttributes<HTMLDivElement>>;
+interface ImageThumbnailsProps extends Omit<React.ComponentPropsWithoutRef<typeof ToggleGroup.Root>, 'type' | 'value' | 'defaultValue' | 'onValueChange'> {
+    /** Slots shown, e.g. 5. Slots past `images.length` render as empty dashed placeholders. */
+    max: number;
+    images: {
+        id: string;
+        src?: string;
+        alt: string;
+    }[];
+    value?: string;
+    onValueChange?: (id: string) => void;
+}
+declare const ImageThumbnails: React.ForwardRefExoticComponent<ImageThumbnailsProps & React.RefAttributes<HTMLDivElement>>;
+interface VideoPlayerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Video source. Without one, the area shows the placeholder fill. */
+    src?: string;
+    name?: string;
+    details?: string[];
+    onRemove?: () => void;
+    /** Called by the "more" (…) button. */
+    onMore?: () => void;
+    /** Initial time values for static previews (seconds). */
+    initialTime?: number;
+    initialDuration?: number;
+}
+declare const VideoPlayer: React.ForwardRefExoticComponent<VideoPlayerProps & React.RefAttributes<HTMLDivElement>>;
+interface VolumeControlProps {
+    /** 0–1. */
+    volume: number;
+    onVolumeChange: (volume: number) => void;
+    className?: string;
+}
+declare function VolumeControl({ volume, onVolumeChange, className }: VolumeControlProps): React.JSX.Element;
+
+interface OpenEndAnswerProps extends Omit<TextareaProps, 'label' | 'description' | 'message' | 'maxLength'> {
+    /** Character limit shown in the counter. */
+    maxLength?: number;
+}
+declare const OpenEndAnswer: React.ForwardRefExoticComponent<OpenEndAnswerProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+declare const QuestionCard: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+
+interface QuestionEditorCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title" | "onChange"> {
+    /** Question number shown in the drag-handle tag. */
+    number: number;
+    title: string;
+    onTitleChange?: (title: string) => void;
+    /** The question is being edited: accent border, counter and footer are shown. */
+    active?: boolean;
+    maxLength?: number;
+    /** Footer label, e.g. "4/20 choices". Shown while `active`. */
+    countLabel?: React.ReactNode;
+    /** Header actions. Defaults to copy, delete and preview buttons wired to the `on*` callbacks. */
+    actions?: React.ReactNode;
+    onDuplicate?: () => void;
+    onDelete?: () => void;
+    onPreview?: () => void;
+    /** Sparkle button beside the card, revealed on hover, focus or while `active`. Omit to hide it. */
+    onAskAi?: () => void;
+    /** Footer: adds an answer choice. Omit (with `onPaste`) to hide the footer buttons. */
+    onAdd?: () => void;
+    /** Footer: opens paste-many-choices. */
+    onPaste?: () => void;
+    /** Optional strip under the card body, e.g. an "Inferred" assumption note. */
+    note?: React.ReactNode;
+}
+declare const QuestionEditorCard: React.ForwardRefExoticComponent<QuestionEditorCardProps & React.RefAttributes<HTMLDivElement>>;
+
+interface QuestionHeaderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title' | 'onChange'> {
+    /** Question number, shown as "QUESTION 01". */
+    number: number;
+    title: React.ReactNode;
+    /** Adds the red asterisk after the title. */
+    required?: boolean;
+    /** Shows an error banner above the header. `true` shows "This question is mandatory."; pass a node for a custom message. */
+    error?: boolean | React.ReactNode;
+    onDismissError?: () => void;
+    /** Editor mode: an editable title with a character counter and hover actions. */
+    editor?: boolean;
+    /** Editor mode: called as the title is typed. `title` must then be a string. */
+    onTitleChange?: (title: string) => void;
+    /** Editor mode: action buttons (copy, delete, preview, AI) revealed on hover or focus. */
+    actions?: React.ReactNode;
+    /** Editor mode: title length limit. */
+    maxLength?: number;
+    /** Editor mode: the question is being edited — the number tag turns accent. */
+    active?: boolean;
+    /** Editor mode: show the "n/2000 characters" counter. Defaults to `true`. */
+    showCounter?: boolean;
+}
+declare const QuestionHeader: React.ForwardRefExoticComponent<QuestionHeaderProps & React.RefAttributes<HTMLDivElement>>;
+
+type QuestionType = 'select-one' | 'select-multiple' | 'ranking' | 'upload' | 'rating' | 'open-end';
+interface QuestionTypeIconProps extends Omit<IconProps, 'weight'> {
+    type: QuestionType;
+}
+declare function QuestionTypeIcon({ type, size, className, ...props }: QuestionTypeIconProps): React.JSX.Element;
+
+interface QuestionNavItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** The question currently open in the editor. */
+    selected?: boolean;
+    /** Question type, shown as the leading 16px duotone icon. */
+    questionType?: QuestionType;
+    /** The question has validation problems — the type icon becomes a warning icon. */
+    error?: boolean;
+    /** Render the child element instead of a `<button>` (e.g. a router link). */
+    asChild?: boolean;
+}
+declare const QuestionNavItem: React.ForwardRefExoticComponent<QuestionNavItemProps & React.RefAttributes<HTMLButtonElement>>;
+
+interface OptionBase {
+    label: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+interface QuestionRadioOptionProps extends OptionBase {
+    kind?: 'radio';
+    /** Value in the surrounding `RadioGroup`. */
+    value: string;
+}
+interface QuestionCheckboxOptionProps extends OptionBase {
+    kind: 'checkbox';
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+type QuestionOptionProps = QuestionRadioOptionProps | QuestionCheckboxOptionProps;
+declare function QuestionOption(props: QuestionOptionProps): React.JSX.Element;
+interface QuestionOtherOptionProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onSubmit'> {
+    /** Called with the typed text when the confirm button (or Enter) is pressed. */
+    onSubmit?: (value: string) => void;
+    confirmLabel?: string;
+}
+declare const QuestionOtherOption: React.ForwardRefExoticComponent<QuestionOtherOptionProps & React.RefAttributes<HTMLInputElement>>;
+interface QuestionOptionEditorProps {
+    label: string;
+    onLabelChange?: (label: string) => void;
+    /** Called by the trash button. */
+    onRemove?: () => void;
+    /** Called by the add (+) button. */
+    onAdd?: () => void;
+    className?: string;
+}
+declare function QuestionOptionEditor({ label, onLabelChange, onRemove, onAdd, className }: QuestionOptionEditorProps): React.JSX.Element;
+
+interface RankItemData {
+    id: string;
+    label: React.ReactNode;
+}
+interface RankListProps extends Omit<React.HTMLAttributes<HTMLOListElement>, 'onChange'> {
+    items: RankItemData[];
+    /** Called with the new order after a drag or a keyboard move. */
+    onItemsChange: (items: RankItemData[]) => void;
+}
+declare const RankList: React.ForwardRefExoticComponent<RankListProps & React.RefAttributes<HTMLOListElement>>;
+
+interface RatingScaleProps extends Omit<React.ComponentPropsWithoutRef<typeof ToggleGroup.Root>, 'type' | 'value' | 'defaultValue' | 'onValueChange'> {
+    /** Number of points on the scale. */
+    max?: number;
+    /** Selected rating (1-based), or `undefined` for none. */
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number | undefined) => void;
+    /** Caption under the first point (e.g. "Not likely"). */
+    lowLabel?: React.ReactNode;
+    /** Caption under the last point (e.g. "Very likely"). */
+    highLabel?: React.ReactNode;
+}
+declare const RatingScale: React.ForwardRefExoticComponent<RatingScaleProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ProgressProps extends React.ComponentPropsWithoutRef<typeof Progress$1.Root> {
+    /** Heading shown above the track, left-aligned (e.g. "Project Progress"). */
+    label?: React.ReactNode;
+    /** Right-aligned value above the track. Pass `true` to render `value%`. */
+    valueLabel?: React.ReactNode | true;
+    /** Left caption below the track (e.g. "16 of 25 tasks completed"). */
+    detailsStart?: React.ReactNode;
+    /** Right caption below the track (e.g. "Est. 3 days remaining"). */
+    detailsEnd?: React.ReactNode;
+}
+declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+
+interface TableProps extends React.TableHTMLAttributes<HTMLTableElement> {
+    /** Alternate row backgrounds (Figma: Stripe = Yes). */
+    striped?: boolean;
+    /** Class names for the bordered, rounded scroll container around the `<table>`. */
+    containerClassName?: string;
+}
+declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /** Highlights the row and marks it with the accent edge (Figma: State = Selected). */
+    selected?: boolean;
+}
+declare const TableRow: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
+type Align = 'left' | 'right';
+interface TableHeadProps extends Omit<React.ThHTMLAttributes<HTMLTableCellElement>, 'align'> {
+    align?: Align;
+    /** Render the label as a sort button. Provide `sort` and `onSort`. */
+    sortable?: boolean;
+    sort?: 'none' | 'asc' | 'desc';
+    onSort?: () => void;
+    /** Narrow centred column for a select-all checkbox. */
+    checkbox?: boolean;
+}
+declare const TableHead: React.ForwardRefExoticComponent<TableHeadProps & React.RefAttributes<HTMLTableCellElement>>;
+interface TableCellProps extends Omit<React.TdHTMLAttributes<HTMLTableCellElement>, 'align'> {
+    align?: Align;
+    /** Secondary text colour (Figma: Type = Muted). */
+    muted?: boolean;
+    /** Narrow centred cell for a checkbox or radio. */
+    checkbox?: boolean;
+    /** Right-aligned cell for row actions; lays its children out in a row with 4px gaps. */
+    actions?: boolean;
+}
+declare const TableCell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+interface TableCellTwoLinesProps extends React.HTMLAttributes<HTMLDivElement> {
+    primary: React.ReactNode;
+    secondary?: React.ReactNode;
+    /** Leading avatar / image (Figma: Two Lines Avatar). */
+    avatar?: React.ReactNode;
+}
+/** Primary + support text stack for a `TableCell` (Figma: Type = Two Lines / Option). Set the row/cell height to `h-14`. */
+declare function TableCellTwoLines({ primary, secondary, avatar, className, ...props }: TableCellTwoLinesProps): React.JSX.Element;
+
+declare const statCardVariants: (props?: ({
+    variant?: "default" | "warning" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StatCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>, VariantProps<typeof statCardVariants> {
+    label: React.ReactNode;
+    value: React.ReactNode;
+    /** Leading icon beside the value (24px). */
+    icon?: React.ReactNode;
+}
+declare const StatCard: React.ForwardRefExoticComponent<StatCardProps & React.RefAttributes<HTMLDivElement>>;
+
+interface ActivityStat extends Pick<StatCardProps, 'label' | 'value' | 'icon' | 'variant'> {
+    id: string;
+}
+interface ActivitySection {
+    id: string;
+    heading: React.ReactNode;
+    body: React.ReactNode;
+    /** Removable tags shown under the body. */
+    tags?: string[];
+}
+interface ActivityStructureProps extends Omit<React.HTMLAttributes<HTMLElement>, 'title'> {
+    title?: React.ReactNode;
+    /** Stat tiles, laid out in a two-column grid. */
+    stats: ActivityStat[];
+    /** Text sections (e.g. Research Goal, Target Audience), optionally with tags. */
+    sections?: ActivitySection[];
+    /** Called with `(sectionId, tag)` when a tag's remove button is pressed. Omit for read-only tags. */
+    onRemoveTag?: (sectionId: string, tag: string) => void;
+    /** Called with the section id by the dashed "Add tag" chip. Omit to hide it. */
+    onAddTag?: (sectionId: string) => void;
+    addTagLabel?: string;
+}
+declare const ActivityStructure: React.ForwardRefExoticComponent<ActivityStructureProps & React.RefAttributes<HTMLElement>>;
+
+declare const tagVariants: (props?: ({
+    variant?: "default" | "destructive" | "success" | "warning" | "neutral" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TagProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof tagVariants> {
+}
+/** Read-only label for system states (Live Interview, Self-paced, AI Interview). */
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+declare const statusDotVariants: (props?: ({
+    status?: "active" | "inactive" | "error" | "pending" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface StatusTagProps extends React.HTMLAttributes<HTMLSpanElement>, Required<Pick<VariantProps<typeof statusDotVariants>, 'status'>> {
+}
+/** White tag with a coloured status dot (Active / Inactive / Pending / Error). */
+declare const StatusTag: React.ForwardRefExoticComponent<StatusTagProps & React.RefAttributes<HTMLSpanElement>>;
+
+interface EditableTagProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onClick'> {
+    /** `default` is the highlighted (primary) value, `editable` is removable, `add` adds a value, `multiple` is the "+N more" overflow chip. */
+    type?: 'default' | 'editable' | 'add' | 'multiple';
+    /** Leading icon. `default` shows a crown unless you pass `null`. */
+    icon?: React.ReactNode;
+    /** Renders a remove button on `editable`/`default` tags. */
+    onRemove?: () => void;
+    /** Click handler for `add` and `multiple` (rendered as a button when set). */
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+    children: React.ReactNode;
+}
+declare const EditableTag: React.ForwardRefExoticComponent<EditableTagProps & React.RefAttributes<HTMLElement>>;
+
+interface RoleTagProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onClick'> {
+    type?: 'primary' | 'secondary' | 'question' | 'interactable';
+    /** Pressed state for `interactable` tags. */
+    selected?: boolean;
+    onClick?: React.MouseEventHandler<HTMLButtonElement>;
+    children: React.ReactNode;
+}
+declare const RoleTag: React.ForwardRefExoticComponent<RoleTagProps & React.RefAttributes<HTMLElement>>;
+
+type PaginationItemValue = number | 'ellipsis';
+/** 1-based page list with ellipses, e.g. `[1, 2, 'ellipsis', 5]`. Keeps first, last and the current page ± `siblings`. */
+declare function getPaginationItems(page: number, pageCount: number, siblings?: number): PaginationItemValue[];
+interface PaginationProps extends Omit<React.HTMLAttributes<HTMLElement>, 'onChange'> {
+    /** Current page, 1-based. */
+    page: number;
+    pageCount: number;
+    onPageChange: (page: number) => void;
+    /** `full` lists page numbers; `compact` shows `1/5` between the arrows. */
+    variant?: 'full' | 'compact';
+    /** How many pages to show either side of the current one (full variant). */
+    siblings?: number;
+}
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+
+export { AIMiniAvatar, type AIMiniAvatarProps, AIResponseContainer, type AIResponseContainerProps, type AIStatus, type ActivitySection, type ActivityStat, ActivityStructure, type ActivityStructureProps, AskAiInput, type AskAiInputProps, AskAiToggle, type AskAiToggleProps, Button, type ButtonProps, Calendar, type CalendarProps, ChatChoices, type ChatChoicesProps, ChatInput, type ChatInputProps, ChatOption, type ChatOptionActionProps, type ChatOptionCheckboxProps, type ChatOptionProps, type ChatOptionRadioProps, Checkbox, CheckboxField, type CheckboxFieldProps, type CheckboxProps, DatePicker, type DatePickerProps, DateTimePicker, type DateTimePickerProps, Dialog, DialogBody, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, DropdownMenuRadioGroup, DropdownMenuRadioItem, type DropdownMenuSelectableItemProps, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, EditableTag, type EditableTagProps, Field, type FieldControlProps, type FieldProps, type FieldStatus, FileAttachment, type FileAttachmentProps, FileUploadItem, type FileUploadItemProps, FileUploadZone, type FileUploadZoneProps, Form, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, FormItem, type FormItemProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, ImagePreview, type ImagePreviewProps, ImageThumbnails, type ImageThumbnailsProps, Input, type InputProps, InputWithAction, type InputWithActionProps, Label, type LabelProps, MediaInfo, type MediaInfoProps, NumberInput, type NumberInputProps, OpenEndAnswer, type OpenEndAnswerProps, Pagination, type PaginationItemValue, type PaginationProps, Progress, type ProgressProps, ProjectSelector, type ProjectSelectorProps, QuestionCard, type QuestionCheckboxOptionProps, QuestionEditorCard, type QuestionEditorCardProps, QuestionHeader, type QuestionHeaderProps, QuestionNavItem, type QuestionNavItemProps, QuestionOption, QuestionOptionEditor, type QuestionOptionEditorProps, type QuestionOptionProps, QuestionOtherOption, type QuestionOtherOptionProps, type QuestionRadioOptionProps, type QuestionType, QuestionTypeIcon, type QuestionTypeIconProps, RadioGroup, RadioGroupFieldItem, type RadioGroupFieldItemProps, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, type RankItemData, RankList, type RankListProps, RatingScale, type RatingScaleProps, RoleTag, type RoleTagProps, SearchBar, type SearchBarProps, Select, SelectContent, type SelectContentProps, SelectGroup, SelectItem, type SelectItemProps, SelectTrigger, type SelectTriggerProps, SelectValue, Slider, type SliderProps, StatCard, type StatCardProps, StatusTag, type StatusTagProps, Switch, type SwitchProps, TabItem, type TabItemProps, TabNavigation, TabNavigationContext, type TabNavigationProps, type TabNavigationVariant, Table, TableBody, TableCell, type TableCellProps, TableCellTwoLines, type TableCellTwoLinesProps, TableHead, type TableHeadProps, TableHeader, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, Tag, type TagProps, Textarea, type TextareaProps, TimeItem, type TimeItemProps, TimePicker, type TimePickerProps, type TimeValue, Timestamp, type TimestampProps, Toast, ToastAction, ToastInline, type ToastInlineProps, type ToastProps, ToastProvider, type ToastVariant, ToastViewport, Toggle, type ToggleProps, Tooltip, TooltipContent, type TooltipContentProps, TooltipProvider, TooltipTrigger, TopicActivityRow, type TopicActivityRowProps, TopicCard, TopicCardMetaItem, type TopicCardMetaItemProps, type TopicCardProps, TopicCardTag, UserMessageBubble, type UserMessageBubbleProps, VideoPlayer, type VideoPlayerProps, VolumeControl, type VolumeControlProps, fieldSurfaceClasses, formatDateTime, getPaginationItems, useFormField };