@takeoff-ui/react-spar 0.2.0 → 0.4.0

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import * as react from 'react';
-import { HTMLAttributes, ElementType, ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
-import { PolymorphicProps, AccordionProps as AccordionProps$1, AccordionItemProps as AccordionItemProps$1, AccordionHeaderProps as AccordionHeaderProps$1, AccordionContentProps as AccordionContentProps$1, BreadcrumbProps as BreadcrumbProps$1, BreadcrumbItemRenderProps, BreadcrumbLinkProps as BreadcrumbLinkProps$1, NavigationHandler, PressEvent, ButtonProps as ButtonProps$1, CheckboxRenderProps as CheckboxRenderProps$1, CheckboxProps as CheckboxProps$1, DialogProps as DialogProps$1, DialogTriggerProps as DialogTriggerProps$1, DialogOverlayProps as DialogOverlayProps$1, DialogContentProps, DialogTitleProps as DialogTitleProps$1, DialogCloseProps as DialogCloseProps$1, FieldProps as FieldProps$1, FieldLabelProps as FieldLabelProps$1, FieldDescriptionProps as FieldDescriptionProps$1, FieldErrorMessageProps as FieldErrorMessageProps$1, InputProps as InputProps$1, InputFieldProps as InputFieldProps$1, LabelProps as LabelProps$1, RadioProps as RadioProps$1, RadioItemRenderProps, RadioItemProps as RadioItemProps$1, PopoverProps as PopoverProps$1, PopoverTriggerProps as PopoverTriggerProps$1, PopoverContentProps as PopoverContentProps$1, PopoverCloseProps as PopoverCloseProps$1, SelectProps as SelectProps$1, SelectTriggerProps as SelectTriggerProps$1, SelectContentProps as SelectContentProps$1, SelectItemProps as SelectItemProps$1, SelectGroupProps as SelectGroupProps$1, SelectLabelProps as SelectLabelProps$1, SelectSeparatorProps as SelectSeparatorProps$1, SwitchRenderProps as SwitchRenderProps$1, SwitchProps as SwitchProps$1, TabsProps as TabsProps$1, TabsListProps as TabsListProps$1, TabsTriggerRenderProps as TabsTriggerRenderProps$1, TabsTriggerProps as TabsTriggerProps$1, TabsContentProps as TabsContentProps$1, TabsActivationMode as TabsActivationMode$1, TooltipTriggerProps as TooltipTriggerProps$1, TooltipContentProps as TooltipContentProps$1, TooltipProps as TooltipProps$1, TooltipProviderProps as TooltipProviderProps$1, ToasterController, ToastData as ToastData$1, ToasterProps as ToasterProps$1, ToastOptions as ToastOptions$1 } from '@turkish-technology/spar';
+import { HTMLAttributes, ElementType, ComponentPropsWithoutRef, ReactNode, Ref, ImgHTMLAttributes } from 'react';
+import { PolymorphicProps, AccordionProps as AccordionProps$1, AccordionItemProps as AccordionItemProps$1, AccordionHeaderProps as AccordionHeaderProps$1, AccordionContentProps as AccordionContentProps$1, BreadcrumbProps as BreadcrumbProps$1, BreadcrumbItemRenderProps, BreadcrumbLinkProps as BreadcrumbLinkProps$1, NavigationHandler, PressEvent, ButtonProps as ButtonProps$1, CheckboxRenderProps as CheckboxRenderProps$1, CheckboxProps as CheckboxProps$1, DialogProps as DialogProps$1, DialogTriggerProps as DialogTriggerProps$1, DialogOverlayProps as DialogOverlayProps$1, DialogContentProps, DialogTitleProps as DialogTitleProps$1, DialogCloseProps as DialogCloseProps$1, DropdownMenuProps, DropdownMenuTriggerProps, DropdownMenuContentProps, DropdownMenuViewportProps, DropdownMenuItemProps, DropdownMenuGroupProps, DropdownMenuLabelProps, DropdownMenuSeparatorProps, DropdownMenuArrowProps, FieldProps as FieldProps$1, FieldLabelProps as FieldLabelProps$1, FieldDescriptionProps as FieldDescriptionProps$1, FieldErrorMessageProps as FieldErrorMessageProps$1, InputProps as InputProps$1, InputFieldProps as InputFieldProps$1, LabelProps as LabelProps$1, RadioProps as RadioProps$1, RadioItemRenderProps, RadioItemProps as RadioItemProps$1, PopoverProps as PopoverProps$1, PopoverTriggerProps as PopoverTriggerProps$1, PopoverContentProps as PopoverContentProps$1, PopoverCloseProps as PopoverCloseProps$1, SelectProps as SelectProps$1, SelectTriggerProps as SelectTriggerProps$1, SelectContentProps as SelectContentProps$1, SelectViewportProps as SelectViewportProps$1, SelectItemProps as SelectItemProps$1, SelectGroupProps as SelectGroupProps$1, SelectLabelProps as SelectLabelProps$1, SelectSeparatorProps as SelectSeparatorProps$1, SwitchRenderProps as SwitchRenderProps$1, SwitchProps as SwitchProps$1, TabsProps as TabsProps$1, TabsListProps as TabsListProps$1, TabsTriggerRenderProps as TabsTriggerRenderProps$1, TabsTriggerProps as TabsTriggerProps$1, TabsContentProps as TabsContentProps$1, TabsActivationMode as TabsActivationMode$1, TooltipTriggerProps as TooltipTriggerProps$1, TooltipContentProps as TooltipContentProps$1, TooltipProps as TooltipProps$1, TooltipProviderProps as TooltipProviderProps$1, ToasterController, ToastData as ToastData$1, ToasterProps as ToasterProps$1, ToastOptions as ToastOptions$1 } from '@turkish-technology/spar';
 export { BreadcrumbItemRenderProps, BreadcrumbPosition, CreateToasterOptions, ToastAnnouncement, ToastPlacement, ToastPromiseOptions, ToastStatus, ToastType, ToastUpdateOptions, ToasterController, createToaster } from '@turkish-technology/spar';
 import * as _tanstack_react_table from '@tanstack/react-table';
 import { HeaderContext, CellContext, Column, FilterFn, RowSelectionState, SortingState, ColumnFiltersState, ExpandedState, PaginationState, Table as Table$1 } from '@tanstack/react-table';
@@ -447,12 +447,6 @@ type BreadcrumbSize = 'base' | 'large';
  * crumb as a bordered, backgrounded chip.
  */
 type BreadcrumbType = 'basic' | 'outlined';
-/**
- * Separator glyph preset. `'chevron'` renders the default chevron icon;
- * `'dot'`, `'slash'`, and `'vertical'` paint the canonical text glyphs from
- * the recipe. Custom `children` override the preset.
- */
-type BreadcrumbSeparatorVariant = 'chevron' | 'dot' | 'slash' | 'vertical';
 
 type BreadcrumbNavigationHandler = NavigationHandler;
 type BreadcrumbPressEvent = PressEvent;
@@ -515,15 +509,10 @@ interface BreadcrumbPageOwnProps {
 type BreadcrumbPageProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, BreadcrumbPageOwnProps>;
 interface BreadcrumbSeparatorOwnProps {
     /**
-     * Override the default separator glyph. Plain content renders inside the
-     * canonical `<li aria-hidden>` owner node and takes priority over `variant`.
+     * Override the default chevron separator. Plain content renders inside the
+     * canonical `<li aria-hidden>` owner node.
      */
     children?: ReactNode;
-    /**
-     * Glyph preset rendered when no `children` are given.
-     * @defaultValue 'chevron'
-     */
-    variant?: BreadcrumbSeparatorVariant;
     /** Per-slot class name overrides. */
     classNames?: ClassNamesMap<BreadcrumbSeparatorSlot>;
     /** Per-slot HTML attribute overrides. */
@@ -907,7 +896,7 @@ declare const Chip: {
  * Side from which the drawer slides in.
  * @defaultValue 'right'
  */
-type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom' | 'full-screen';
+type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom';
 type DrawerOverlaySlot = 'root';
 type DrawerPanelSlot = 'root';
 type DrawerHeaderSlot = 'root';
@@ -1177,6 +1166,203 @@ declare const Dialog: {
     };
 };
 
+type DividerOrientation = 'horizontal' | 'vertical';
+type DividerAppearance = 'solid' | 'dashed' | 'dotted';
+type DividerAlign = 'start' | 'center' | 'end';
+type DividerSlot = 'root' | 'label';
+interface DividerProps extends Omit<TakeoffHTMLProps<'div'>, 'children' | 'role' | 'aria-orientation'> {
+    /**
+     * Axis of the divider line. Vertical dividers size from their container —
+     * place them in a flex row (or give the parent an explicit height) so the
+     * line has a height to fill.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: DividerOrientation;
+    /**
+     * Line style.
+     * @defaultValue 'solid'
+     */
+    appearance?: DividerAppearance;
+    /**
+     * Placement of the label along the divider line.
+     * @defaultValue 'center'
+     */
+    align?: DividerAlign;
+    /**
+     * Marks the divider as purely visual. Decorative dividers are removed from
+     * the accessibility tree (`role="none"`); non-decorative dividers render
+     * `role="separator"` with the matching `aria-orientation`.
+     * @defaultValue false
+     */
+    decorative?: boolean;
+    /**
+     * Label content rendered between the line segments. The ARIA `separator`
+     * role does not take its accessible name from content — pass `aria-label`
+     * when the separator needs a name.
+     */
+    children?: ReactNode;
+    /** Ref forwarded to the root div element. */
+    ref?: Ref<HTMLDivElement>;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<DividerSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<DividerSlot>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Divider: ComponentThemeConfig<DividerProps, DividerSlot>;
+    }
+}
+
+declare const Divider: {
+    (props: DividerProps): react.JSX.Element;
+    displayName: string;
+};
+
+type DropdownSize = 'small' | 'base' | 'large';
+/**
+ * Controls the panel's render width.
+ *
+ * - `'content'`: panel shrink-wraps the longest item, only enforcing the CSS min-width
+ * - `'trigger'`: panel matches the trigger's measured width
+ * - `number`: explicit pixel width
+ * - `string`: any CSS width value (`'20rem'`, `'min(40ch, 100%)'`, etc.)
+ */
+type DropdownContentWidth = 'content' | 'trigger' | number | string;
+type DropdownTriggerSlot = 'root';
+type DropdownContentSlot = 'root';
+type DropdownViewportSlot = 'root';
+type DropdownItemSlot = 'root';
+type DropdownGroupSlot = 'root';
+type DropdownLabelSlot = 'root';
+type DropdownSeparatorSlot = 'root';
+type DropdownArrowSlot = 'root';
+interface DropdownOwnProps {
+    /**
+     * Size scale for the menu content and items.
+     * @defaultValue 'base'
+     */
+    size?: DropdownSize;
+    /**
+     * How the portalled Dropdown.Content panel computes its width. See
+     * {@link DropdownContentWidth}.
+     * @defaultValue 'content'
+     */
+    contentWidth?: DropdownContentWidth;
+}
+/**
+ * Public props for the Dropdown root. State-only — renders no DOM, so no
+ * polymorphic `as` and no native HTML props.
+ */
+type DropdownProps = DropdownOwnProps & Pick<DropdownMenuProps, 'id' | 'open' | 'defaultOpen' | 'onOpenChange' | 'modal' | 'disabled' | 'closeOnSelect' | 'children'>;
+interface DropdownTriggerOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownTriggerSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownTriggerSlot>;
+}
+type DropdownTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DropdownTriggerOwnProps & Pick<DropdownMenuTriggerProps, 'children'>>;
+interface DropdownContentOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownContentSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownContentSlot>;
+}
+type DropdownContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DropdownContentOwnProps & Pick<DropdownMenuContentProps, 'side' | 'align' | 'container' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onFocusOutside'>>;
+interface DropdownViewportOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownViewportSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownViewportSlot>;
+}
+type DropdownViewportProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DropdownViewportOwnProps & Pick<DropdownMenuViewportProps, 'children'>>;
+interface DropdownItemOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownItemSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownItemSlot>;
+}
+type DropdownItemProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DropdownItemOwnProps & Pick<DropdownMenuItemProps, 'disabled' | 'onSelect' | 'textValue'>>;
+interface DropdownGroupOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownGroupSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownGroupSlot>;
+}
+type DropdownGroupProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DropdownGroupOwnProps & Pick<DropdownMenuGroupProps, 'children'>>;
+interface DropdownLabelOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownLabelSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownLabelSlot>;
+}
+type DropdownLabelProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DropdownLabelOwnProps & Pick<DropdownMenuLabelProps, 'children'>>;
+interface DropdownSeparatorOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownSeparatorSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownSeparatorSlot>;
+}
+type DropdownSeparatorProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DropdownSeparatorOwnProps & Pick<DropdownMenuSeparatorProps, 'children'>>;
+interface DropdownArrowOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<DropdownArrowSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<DropdownArrowSlot>;
+}
+type DropdownArrowProps<T extends ElementType = 'svg'> = PolymorphicProps<'svg', T, DropdownArrowOwnProps & Pick<DropdownMenuArrowProps, 'children'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Dropdown: StateOnlyComponentThemeConfig<DropdownProps>;
+        DropdownTrigger: ComponentThemeConfig<DropdownTriggerProps, DropdownTriggerSlot>;
+        DropdownContent: ComponentThemeConfig<DropdownContentProps, DropdownContentSlot>;
+        DropdownViewport: ComponentThemeConfig<DropdownViewportProps, DropdownViewportSlot>;
+        DropdownItem: ComponentThemeConfig<DropdownItemProps, DropdownItemSlot>;
+        DropdownGroup: ComponentThemeConfig<DropdownGroupProps, DropdownGroupSlot>;
+        DropdownLabel: ComponentThemeConfig<DropdownLabelProps, DropdownLabelSlot>;
+        DropdownSeparator: ComponentThemeConfig<DropdownSeparatorProps, DropdownSeparatorSlot>;
+        DropdownArrow: ComponentThemeConfig<DropdownArrowProps, DropdownArrowSlot>;
+    }
+}
+
+declare const Dropdown: {
+    (props: DropdownProps): react.JSX.Element;
+    displayName: string;
+} & {
+    Trigger: {
+        <T extends react.ElementType = "button">(props: DropdownTriggerProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        <T extends react.ElementType = "div">(props: DropdownContentProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Viewport: {
+        <T extends react.ElementType = "div">(props: DropdownViewportProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        <T extends react.ElementType = "div">(props: DropdownItemProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Group: {
+        <T extends react.ElementType = "div">(props: DropdownGroupProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Label: {
+        <T extends react.ElementType = "div">(props: DropdownLabelProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Separator: {
+        <T extends react.ElementType = "div">(props: DropdownSeparatorProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Arrow: {
+        <T extends react.ElementType = "svg">(props: DropdownArrowProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+};
+
 type FieldSlot = 'root';
 type FieldLabelSlot = 'root' | 'asterisk';
 type FieldDescriptionSlot = 'root' | 'icon';
@@ -1715,6 +1901,174 @@ declare const Popover: {
     };
 };
 
+/** Shape of the progress indicator. */
+type ProgressAppearance = 'linear' | 'circular';
+/** Visual scale. */
+type ProgressSize = 'small' | 'base' | 'large';
+/** Fill color variant. */
+type ProgressVariant = 'primary' | 'info' | 'success' | 'danger' | 'warning';
+type ProgressSlot = 'root';
+type ProgressTrackSlot = 'root' | 'rail';
+type ProgressIndicatorSlot = 'root';
+type ProgressValueSlot = 'root';
+/**
+ * Props owned by takeoff-v2. There is no Spar Progress primitive to `Pick`
+ * from — the whole surface is wrapper-owned (see the react-enhancement
+ * rationale in `base.ts`).
+ */
+interface ProgressOwnProps {
+    /**
+     * Current progress value. Clamped to `[min, max]`; non-finite values
+     * resolve to `min`. Ignored while `indeterminate` is set.
+     * @defaultValue 0
+     */
+    value?: number;
+    /**
+     * Marks the progress as indeterminate — the root drops `aria-valuenow`,
+     * emits `data-indeterminate`, and the indicator animates a looping sweep
+     * instead of a fill. Takes precedence over `value`.
+     * @defaultValue false
+     */
+    indeterminate?: boolean;
+    /**
+     * Minimum value the progress starts from. Non-finite values fall back to
+     * the default.
+     * @defaultValue 0
+     */
+    min?: number;
+    /**
+     * Maximum value the progress can reach. Non-finite values and values at or
+     * below `min` fall back to `min + 100` (the latter with a dev-only console
+     * warning, since an inverted range is a consumer bug).
+     * @defaultValue 100
+     */
+    max?: number;
+    /**
+     * Shape of the progress indicator — a horizontal bar (`'linear'`) or a
+     * ring (`'circular'`).
+     * @defaultValue 'linear'
+     */
+    appearance?: ProgressAppearance;
+    /**
+     * Visual scale. Linear progress changes track height; circular progress
+     * changes ring diameter.
+     * @defaultValue 'base'
+     */
+    size?: ProgressSize;
+    /**
+     * Fill color variant.
+     * @defaultValue 'primary'
+     */
+    variant?: ProgressVariant;
+    /**
+     * Mutes the fill color and sets `aria-disabled`. Inherits the surrounding
+     * `Field`'s disabled state when composed inside one.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Optional anatomy override. When omitted, `Progress` renders the default
+     * anatomy — `Progress.Track` wrapping `Progress.Indicator` — for both
+     * appearances.
+     */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<ProgressSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<ProgressSlot>;
+}
+/**
+ * Public props for the Progress root — the a11y owner and layout wrapper
+ * (the track is its own part, `Progress.Track`, matching the
+ * Root/Label/Track/Indicator anatomy convention). Renders the default
+ * anatomy when no children are given. Compose inside a `Field` with
+ * `Field.Label` for an automatically wired visible label.
+ */
+type ProgressProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, ProgressOwnProps>;
+interface ProgressTrackOwnProps {
+    /**
+     * Track anatomy override. When omitted, `Progress.Track` renders the
+     * default `Progress.Indicator`.
+     */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<ProgressTrackSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<ProgressTrackSlot>;
+}
+/**
+ * Public props for `Progress.Track` — the rail the indicator fills. The
+ * element is decided by the root's `appearance`: a rail `<div>` for
+ * `'linear'`, the ring `<svg>` for `'circular'` — where the rail is drawn
+ * as the svg's own `<circle>`, exposed as the `'rail'` slot.
+ */
+type ProgressTrackProps = ProgressTrackOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<Element>;
+};
+interface ProgressIndicatorOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<ProgressIndicatorSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<ProgressIndicatorSlot>;
+}
+/**
+ * Public props for `Progress.Indicator` — the filled portion. Not
+ * polymorphic — the element is decided by the root's `appearance` (linear
+ * fill `<span>` / circular arc `<circle>`), and the indicator takes no
+ * children.
+ */
+type ProgressIndicatorProps = ProgressIndicatorOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<Element>;
+};
+interface ProgressValueOwnProps {
+    /**
+     * Visible value content — typically the formatted value (e.g. `%60`) or a
+     * short status. The component renders no default content; formatting stays
+     * with the consumer so locale and design conventions are not baked in.
+     */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<ProgressValueSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<ProgressValueSlot>;
+}
+/**
+ * Public props for `Progress.Value` — decorative (`aria-hidden`) value or
+ * status text. The value is announced through the root's `aria-valuenow`,
+ * so the value text carries no accessibility semantics. Renders in flow
+ * next to the track for `'linear'` and as an overlay centered inside the
+ * ring for `'circular'`.
+ */
+type ProgressValueProps = ProgressValueOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<HTMLSpanElement>;
+};
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Progress: ComponentThemeConfig<ProgressProps, ProgressSlot>;
+        ProgressTrack: ComponentThemeConfig<ProgressTrackProps, ProgressTrackSlot>;
+        ProgressIndicator: ComponentThemeConfig<ProgressIndicatorProps>;
+        ProgressValue: ComponentThemeConfig<ProgressValueProps>;
+    }
+}
+
+declare const Progress: {
+    <T extends react.ElementType = "div">(props: ProgressProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    Track: {
+        (props: ProgressTrackProps): react.JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        (props: ProgressIndicatorProps): react.JSX.Element;
+        displayName: string;
+    };
+    Value: {
+        (props: ProgressValueProps): react.JSX.Element;
+        displayName: string;
+    };
+};
+
 type SelectSize = 'small' | 'base' | 'large';
 /**
  * Controls the panel's render width.
@@ -1729,10 +2083,12 @@ type SelectSlot = 'root';
 type SelectTriggerSlot = 'root' | 'value' | 'indicator';
 type SelectIndicatorSlot = 'root';
 type SelectContentSlot = 'root';
+type SelectViewportSlot = 'root';
 type SelectItemSlot = 'root';
 type SelectGroupSlot = 'root';
 type SelectLabelSlot = 'root';
 type SelectSeparatorSlot = 'root';
+type SelectArrowSlot = 'root';
 /**
  * Visual + slot props owned by takeoff-v2 for the Select root. `size` and
  * `invalid` cascade to the Trigger through a visual context so consumers
@@ -1820,6 +2176,13 @@ interface SelectContentOwnProps {
     slotProps?: SlotPropsMap<SelectContentSlot>;
 }
 type SelectContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectContentOwnProps & Pick<SelectContentProps$1, 'side' | 'align' | 'container' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onCloseAutoFocus'>>;
+interface SelectViewportOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectViewportSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectViewportSlot>;
+}
+type SelectViewportProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectViewportOwnProps & Pick<SelectViewportProps$1, 'children'>>;
 interface SelectItemOwnProps {
     /** Per-slot class name overrides. */
     classNames?: ClassNamesMap<SelectItemSlot>;
@@ -1848,16 +2211,31 @@ interface SelectSeparatorOwnProps {
     slotProps?: SlotPropsMap<SelectSeparatorSlot>;
 }
 type SelectSeparatorProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectSeparatorOwnProps & Pick<SelectSeparatorProps$1, 'children'>>;
+interface SelectArrowOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectArrowSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectArrowSlot>;
+}
+/**
+ * Optional decorative arrow pointing at the trigger. Positioned automatically by
+ * Spar's Floating UI middleware; renders a default triangle `<svg>` whose fill
+ * follows the recipe's `color`. No Spar props are surfaced — the polymorphic svg
+ * attributes (incl. `children` for a custom shape) come through directly.
+ */
+type SelectArrowProps<T extends ElementType = 'svg'> = PolymorphicProps<'svg', T, SelectArrowOwnProps>;
 declare module '../../core/theme' {
     interface ComponentThemeRegistry {
         Select: ComponentThemeConfig<SelectProps, SelectSlot>;
         SelectTrigger: ComponentThemeConfig<SelectTriggerProps, SelectTriggerSlot>;
         SelectIndicator: ComponentThemeConfig<SelectIndicatorProps, SelectIndicatorSlot>;
         SelectContent: ComponentThemeConfig<SelectContentProps, SelectContentSlot>;
+        SelectViewport: ComponentThemeConfig<SelectViewportProps, SelectViewportSlot>;
         SelectItem: ComponentThemeConfig<SelectItemProps, SelectItemSlot>;
         SelectGroup: ComponentThemeConfig<SelectGroupProps, SelectGroupSlot>;
         SelectLabel: ComponentThemeConfig<SelectLabelProps, SelectLabelSlot>;
         SelectSeparator: ComponentThemeConfig<SelectSeparatorProps, SelectSeparatorSlot>;
+        SelectArrow: ComponentThemeConfig<SelectArrowProps, SelectArrowSlot>;
     }
 }
 
@@ -1877,6 +2255,10 @@ declare const Select: {
         <T extends react.ElementType = "div">(props: SelectContentProps<T>): react.JSX.Element;
         displayName: string;
     };
+    Viewport: {
+        <T extends react.ElementType = "div">(props: SelectViewportProps<T>): react.JSX.Element;
+        displayName: string;
+    };
     Item: {
         <T extends react.ElementType = "div">(props: SelectItemProps<T>): react.JSX.Element;
         displayName: string;
@@ -1893,76 +2275,656 @@ declare const Select: {
         <T extends react.ElementType = "div">(props: SelectSeparatorProps<T>): react.JSX.Element;
         displayName: string;
     };
+    Arrow: {
+        <T extends react.ElementType = "svg">(props: SelectArrowProps<T>): react.JSX.Element;
+        displayName: string;
+    };
 };
 
-type SpinnerSize = 'small' | 'base' | 'large' | 'xlarge';
-type SpinnerAppearance = 'rounded' | 'dots' | 'lines' | 'pulse' | 'threeDots' | 'loader' | 'logo';
-type SpinnerVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning';
-type SpinnerSlot = 'root' | 'indicator';
-interface SpinnerProps extends Omit<TakeoffHTMLProps<'span'>, 'children'> {
+/** Axis the rail runs along. A vertical rail runs bottom-to-top: the bottom edge is `min`. */
+type SliderOrientation = 'horizontal' | 'vertical';
+/** Visual scale. */
+type SliderSize = 'small' | 'base' | 'large';
+/** Fill color variant. */
+type SliderVariant = 'primary' | 'info' | 'success' | 'danger' | 'warning';
+/** When the drag value bubble is shown. */
+type SliderTooltip = 'auto' | 'always' | 'never';
+/** How the rail fill renders. `none` drops the fill but keeps the rail. */
+type SliderTrackMode = 'normal' | 'inverted' | 'none';
+/**
+ * Committed slider value. A single `number` when `range` is unset, an ascending
+ * array when `range` is set. Takeoff Core's `tk-slider` commits a `[min, max]`
+ * pair only; the array widens that so a range can carry more than two handles.
+ */
+type SliderValue = number | number[];
+type SliderSlot = 'root';
+type SliderTrackSlot = 'root';
+type SliderRangeSlot = 'root';
+type SliderThumbSlot = 'root' | 'tooltip' | 'arrow';
+type SliderTicksSlot = 'root' | 'tick';
+type SliderValueSlot = 'root';
+/**
+ * Value surface for a single-thumb slider. `range` is optional here so the
+ * single form stays the zero-config default.
+ */
+interface SliderSingleValueProps {
     /**
-     * Size scale.
-     * @defaultValue 'base'
+     * Renders a multi-handle slider that commits an array instead of a number.
+     * `range` is a discriminated union (`false` vs `true`), not a plain
+     * `boolean`, so a value typed `boolean` matches neither arm — to toggle mode
+     * at runtime, branch on the flag and render the single vs range `<Slider>`
+     * explicitly rather than passing `range={isRange}`.
+     * @defaultValue false
      */
-    size?: SpinnerSize;
+    range?: false;
     /**
-     * Visual spinner style.
-     * @defaultValue 'rounded'
+     * Controlled value. Clamped into `[min, max]` and snapped to `step`. Takes
+     * precedence: passing this alongside `defaultValue` makes the slider
+     * controlled and ignores `defaultValue` (a dev-only warning is logged).
      */
-    appearance?: SpinnerAppearance;
+    value?: number;
     /**
-     * Color variant.
-     * @defaultValue 'neutral'
+     * Initial value for uncontrolled usage. Ignored when `value` is also given.
+     * Controlled/uncontrolled mode is latched on the first render, so a `value`
+     * that later becomes `undefined` does not hand control back.
+     * @defaultValue `min`
      */
-    variant?: SpinnerVariant;
-    /** Ref forwarded to the root span element. */
-    ref?: Ref<HTMLSpanElement>;
-    /** Per-slot extra classes. */
-    classNames?: ClassNamesMap<SpinnerSlot>;
-    /** Per-slot HTML-attribute overrides. */
-    slotProps?: SlotPropsMap<SpinnerSlot>;
+    defaultValue?: number;
+    /** Fired on every committed value change while interacting — each drag frame, keystroke, or track press. */
+    onValueChange?: (value: number) => void;
+    /**
+     * Fired once at the end of an interaction with the final value: on pointer
+     * release after a drag or track press, and once per committed keystroke. Use
+     * it when only the settled value matters (persist, refetch, validate), while
+     * `onValueChange` streams the live value.
+     */
+    onValueChangeEnd?: (value: number) => void;
 }
-declare module '../../core/theme' {
-    interface ComponentThemeRegistry {
-        Spinner: ComponentThemeConfig<SpinnerProps, SpinnerSlot>;
-    }
+/** Value surface for a two-thumb range slider. */
+interface SliderRangeValueProps {
+    /**
+     * Renders one thumb per entry of `value` / `defaultValue` (two by default)
+     * and commits an ascending array.
+     */
+    range: true;
+    /**
+     * Controlled values, one per handle — its length decides how many thumbs
+     * render. Fewer than two entries fall back to `[min, max]`, as with
+     * `defaultValue`. Each entry is clamped into `[min, max]`, snapped to `step`,
+     * and the array is ordered ascending. Takes precedence: passing this alongside
+     * `defaultValue` makes the slider controlled and ignores `defaultValue`.
+     */
+    value?: number[];
+    /**
+     * Initial values for uncontrolled usage, one per handle. Fewer than two
+     * entries falls back to `[min, max]`. Ignored when `value` is also given.
+     * Controlled/uncontrolled mode is latched on the first render, so a `value`
+     * that later becomes `undefined` does not hand control back.
+     * @defaultValue `[min, max]`
+     */
+    defaultValue?: number[];
+    /** Fired on every committed value change while interacting — each drag frame, keystroke, or track press. */
+    onValueChange?: (value: number[]) => void;
+    /**
+     * Fired once at the end of an interaction with the final values: on pointer
+     * release after a drag or track press, and once per committed keystroke.
+     */
+    onValueChangeEnd?: (value: number[]) => void;
 }
-
-declare const Spinner: {
-    (props: SpinnerProps): react.JSX.Element;
-    displayName: string;
-};
-
-type SwitchSize = 'xlarge' | 'large' | 'base' | 'small' | 'xsmall';
-type SwitchVariant = 'info' | 'success';
-type SwitchSlot = 'root' | 'indicator' | 'thumb';
-/**
- * Render props passed to the root `Switch` render-prop child. Re-exports
- * Spar's shape verbatim — consumers reading the state inside compound
- * children should use `Switch.Indicator` render-prop instead, which receives
- * the takeoff-spar split via context.
- */
-type SwitchRenderProps = SwitchRenderProps$1;
 /**
- * Render props passed to `Switch.Indicator` function-children. Mirrors the
- * shape used by `Checkbox.Indicator`.
+ * Props owned by takeoff-v2. There is no Spar Slider primitive to `Pick`
+ * from — the whole surface is wrapper-owned (see the react-enhancement
+ * rationale in `base.ts`).
  */
-interface SwitchIndicatorRenderProps {
-    checked: boolean;
-    disabled: boolean;
-    readOnly: boolean;
-}
-interface SwitchOwnProps {
+interface SliderOwnProps {
     /**
-     * Size scale.
-     * @defaultValue 'base'
+     * Lowest selectable value. Non-finite values fall back to the default.
+     * @defaultValue 0
      */
-    size?: SwitchSize;
+    min?: number;
     /**
-     * Color variant used while checked.
-     * @defaultValue 'info'
+     * Highest selectable value. Non-finite values and values at or below `min`
+     * fall back to `min + 100` (with a dev-only console warning, since an
+     * inverted range is a consumer bug).
+     * @defaultValue 100
      */
-    variant?: SwitchVariant;
+    max?: number;
+    /**
+     * Granularity the value snaps to, counted from `min`. Non-finite and
+     * non-positive values fall back to the default.
+     * @defaultValue 1
+     */
+    step?: number;
+    /**
+     * Minimum gap kept between adjacent thumbs of a range, in value units. With a
+     * positive gap the handles can no longer cross — dragging one into another
+     * stops it against its neighbour instead of swapping. Ignored by a single
+     * slider; initial values are not reshaped, so seed them at least this far apart.
+     * @defaultValue 0
+     */
+    minDistance?: number;
+    /**
+     * Blocks interaction and mutes the fill. Inherits the surrounding `Field`'s
+     * disabled state when composed inside one.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Renders the value but blocks every value-changing interaction. Inherits
+     * the surrounding `Field`'s read-only state when composed inside one.
+     * @defaultValue false
+     */
+    readOnly?: boolean;
+    /**
+     * Marks the slider as required for form validation. Inherits the
+     * surrounding `Field`'s required state when composed inside one.
+     * @defaultValue false
+     */
+    required?: boolean;
+    /**
+     * Applies the invalid treatment and sets `aria-invalid` on every thumb.
+     * Inherits the surrounding `Field`'s invalid state when composed inside one.
+     * @defaultValue false
+     */
+    invalid?: boolean;
+    /**
+     * Axis the rail runs along. A vertical rail runs bottom-to-top and fills its
+     * container's height (as a horizontal rail fills its width), so give the
+     * parent a height.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: SliderOrientation;
+    /**
+     * Visual scale — changes track thickness and thumb diameter.
+     * @defaultValue 'base'
+     */
+    size?: SliderSize;
+    /**
+     * Fill color variant.
+     * @defaultValue 'primary'
+     */
+    variant?: SliderVariant;
+    /**
+     * How the rail fill renders. `normal` fills from the start to the thumb (or
+     * between a range's thumbs); `inverted` fills the *complement* instead — from
+     * the thumb to the end for a single slider, and outside the two handles for a
+     * range; `none` drops the fill entirely, leaving just the rail and the thumbs.
+     * @defaultValue 'normal'
+     */
+    track?: SliderTrackMode;
+    /**
+     * When the drag value bubble is shown. `auto` reveals it while the handle is
+     * dragged or keyboard-focused; `always` pins it open; `never` hides it
+     * entirely — handy when a `Slider.Value` already surfaces the number. A
+     * disabled slider hides the bubble regardless.
+     * @defaultValue 'auto'
+     */
+    tooltip?: SliderTooltip;
+    /**
+     * Formats a value for every readout — the drag tooltip, `Slider.Value`, and
+     * `aria-valuetext`. Returns a string, so it formats the value rather than
+     * overriding the rendered node; use `Slider.Thumb` / `Slider.Value` children
+     * for richer content. When omitted, the raw number is shown and
+     * `aria-valuetext` is dropped.
+     */
+    formatValue?: (value: number) => string;
+    /**
+     * Name submitted with the form. A single slider submits one entry under this
+     * exact name; a two-handle range submits `-min` / `-max`, and a range with
+     * more handles submits each value under a 1-based `-1`, `-2`, … suffix so no
+     * handle is dropped.
+     */
+    name?: string;
+    /** `id` of the form the hidden inputs belong to. */
+    form?: string;
+    /**
+     * Optional anatomy override. When omitted, `Slider` renders the default
+     * anatomy — `Slider.Track`, wrapping `Slider.Range` and one thumb per value.
+     * Compose the parts explicitly to add an indicator such as `Slider.Ticks`
+     * below the rail.
+     */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SliderSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SliderSlot>;
+}
+/**
+ * Public props for the Slider root — the layout wrapper and state owner.
+ * Each thumb is the `role="slider"` a11y owner, so a range root additionally
+ * takes `role="group"` to tie the pair together. Renders the default anatomy
+ * when no children are given. Compose inside a `Field` with `Field.Label` for
+ * an automatically wired visible label.
+ */
+type SliderProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SliderOwnProps & (SliderSingleValueProps | SliderRangeValueProps)>;
+interface SliderTrackOwnProps {
+    /**
+     * Track anatomy override. When omitted, `Slider.Track` renders the default
+     * `Slider.Range` plus one thumb per value.
+     */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SliderTrackSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SliderTrackSlot>;
+}
+/**
+ * Public props for `Slider.Track` — the rail the thumbs travel along. Owns
+ * the press-to-seek interaction: pressing the rail moves the nearest thumb to
+ * that position and starts dragging it.
+ */
+type SliderTrackProps = SliderTrackOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<HTMLDivElement>;
+};
+interface SliderRangeOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SliderRangeSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SliderRangeSlot>;
+}
+/**
+ * Public props for `Slider.Range` — the filled portion of the track. Takes no
+ * children; its offset and length are written inline from the committed
+ * values (a continuous value is not a `data-*` hook).
+ */
+type SliderRangeProps = SliderRangeOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<HTMLSpanElement>;
+};
+/** State handed to `Slider.Thumb` function-children. */
+interface SliderThumbRenderProps {
+    /** Committed value of this thumb. */
+    value: number;
+    /** `value` passed through the root's `formatValue`, or stringified when the root has no formatter. */
+    formatted: string;
+    /** Which value this thumb controls. */
+    index: number;
+    /** Whether the pointer currently controls this thumb. */
+    isDragging: boolean;
+    /** Whether this thumb holds keyboard focus. */
+    isFocused: boolean;
+}
+interface SliderThumbOwnProps {
+    /**
+     * Which value this thumb controls. The default anatomy renders index `0`
+     * (and `1` for a range slider); pass it explicitly only when composing the
+     * thumbs by hand.
+     * @defaultValue 0
+     */
+    index?: number;
+    /**
+     * Disables just this handle: it cannot be moved by pointer or keyboard and is
+     * skipped as a drag target, while the other thumbs stay interactive. A
+     * neighbouring thumb dragged into a disabled one stops against it rather than
+     * pushing it. The whole slider's `disabled` still disables every thumb.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Content of the value bubble. When omitted, the formatted value renders. A
+     * plain node replaces it with static content; a function receives this
+     * thumb's `value` / `formatted` / `index` / `isDragging` / `isFocused` for
+     * content that reacts to the drag. Either form swaps only what the bubble
+     * shows — the handle and the bubble chrome are always the thumb's.
+     */
+    children?: ReactNode | ((state: SliderThumbRenderProps) => ReactNode);
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SliderThumbSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SliderThumbSlot>;
+}
+/**
+ * Public props for `Slider.Thumb` — the draggable handle and the
+ * `role="slider"` a11y owner (keyboard, ARIA value surface, focus). Renders a
+ * CSS-positioned value bubble whose content `children` replace.
+ */
+type SliderThumbProps = SliderThumbOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<HTMLSpanElement>;
+};
+interface SliderTicksOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SliderTicksSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SliderTicksSlot>;
+}
+/**
+ * Public props for `Slider.Ticks` — decorative (`aria-hidden`) marks at every
+ * step. Opt-in: compose it after `Slider.Track` to show the step grid.
+ */
+type SliderTicksProps = SliderTicksOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<HTMLDivElement>;
+};
+/** State handed to `Slider.Value` function-children. */
+interface SliderValueRenderProps {
+    /** Committed thumb values — one entry, or two ascending entries for a range. */
+    values: number[];
+    /** Each value passed through the root's `formatValue`, or stringified when the root has no formatter. */
+    formatted: string[];
+    /** Mirrors the root's `range` prop. */
+    range: boolean;
+}
+interface SliderValueOwnProps {
+    /**
+     * Readout content. When omitted, `Slider.Value` renders the formatted
+     * value — both entries joined by an en dash for a range. A function receives
+     * the committed values and their formatted strings, which is the only way to
+     * read the value of an **uncontrolled** slider without lifting state out of
+     * the component.
+     */
+    children?: ReactNode | ((state: SliderValueRenderProps) => ReactNode);
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SliderValueSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SliderValueSlot>;
+}
+/**
+ * Public props for `Slider.Value` — decorative (`aria-hidden`) value readout.
+ * Each value is already announced through its thumb's `aria-valuenow`, so the
+ * text carries no accessibility semantics. Opt-in: compose it alongside
+ * `Slider.Track`.
+ */
+type SliderValueProps = SliderValueOwnProps & Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    ref?: Ref<HTMLSpanElement>;
+};
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Slider: ComponentThemeConfig<SliderProps, SliderSlot>;
+        SliderTrack: ComponentThemeConfig<SliderTrackProps, SliderTrackSlot>;
+        SliderRange: ComponentThemeConfig<SliderRangeProps, SliderRangeSlot>;
+        SliderThumb: ComponentThemeConfig<SliderThumbProps, SliderThumbSlot>;
+        SliderTicks: ComponentThemeConfig<SliderTicksProps, SliderTicksSlot>;
+        SliderValue: ComponentThemeConfig<SliderValueProps, SliderValueSlot>;
+    }
+}
+
+declare const Slider: {
+    <T extends react.ElementType = "div">(props: SliderProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    Track: {
+        (props: SliderTrackProps): react.JSX.Element;
+        displayName: string;
+    };
+    Range: {
+        (props: SliderRangeProps): react.JSX.Element;
+        displayName: string;
+    };
+    Thumb: {
+        (props: SliderThumbProps): react.JSX.Element;
+        displayName: string;
+    };
+    Ticks: {
+        (props: SliderTicksProps): react.JSX.Element | null;
+        displayName: string;
+    };
+    Value: {
+        (props: SliderValueProps): react.JSX.Element;
+        displayName: string;
+    };
+};
+
+type SpinnerSize = 'small' | 'base' | 'large' | 'xlarge';
+type SpinnerAppearance = 'rounded' | 'dots' | 'lines' | 'pulse' | 'threeDots' | 'loader' | 'logo';
+type SpinnerVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning';
+type SpinnerSlot = 'root' | 'indicator';
+interface SpinnerProps extends Omit<TakeoffHTMLProps<'span'>, 'children'> {
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: SpinnerSize;
+    /**
+     * Visual spinner style.
+     * @defaultValue 'rounded'
+     */
+    appearance?: SpinnerAppearance;
+    /**
+     * Color variant.
+     * @defaultValue 'neutral'
+     */
+    variant?: SpinnerVariant;
+    /** Ref forwarded to the root span element. */
+    ref?: Ref<HTMLSpanElement>;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<SpinnerSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<SpinnerSlot>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Spinner: ComponentThemeConfig<SpinnerProps, SpinnerSlot>;
+    }
+}
+
+declare const Spinner: {
+    (props: SpinnerProps): react.JSX.Element;
+    displayName: string;
+};
+
+/** Layout axis of the step list. */
+type StepperOrientation = 'horizontal' | 'vertical';
+/**
+ * Display mode. `'default'` renders indicators with connecting rails; `'compact'`
+ * drops the rails in favor of a progress border on each step.
+ */
+type StepperMode = 'default' | 'compact';
+/** Density scale for indicators and typography. */
+type StepperSize = 'large' | 'base' | 'small' | 'xsmall';
+/**
+ * Resolved progress status of a step. Error and disabled are exposed as
+ * separate modifier states so an active/completed step can also be errored.
+ */
+type StepperStepStatus = 'inactive' | 'active' | 'completed';
+/** Payload of the root `onStepClick` callback. */
+interface StepperStepClickDetail {
+    /** Zero-based index of the pressed step. */
+    index: number;
+    /** Status of the pressed step at press time. */
+    status: StepperStepStatus;
+}
+/** State passed to a `Stepper.Item` `indicator` render function. */
+interface StepperIndicatorState {
+    /** Resolved progress status of the step. */
+    status: StepperStepStatus;
+    /** Zero-based index of the step. */
+    index: number;
+}
+type StepperSlot = 'root';
+type StepperItemSlot = 'root' | 'trigger' | 'rail' | 'indicator' | 'content';
+type StepperTitleSlot = 'root';
+type StepperDescriptionSlot = 'root';
+/**
+ * Props owned by takeoff-v2. There is no Spar Stepper primitive to `Pick`
+ * from — the whole surface is wrapper-owned (see the react-enhancement
+ * rationale in `base.ts`).
+ */
+interface StepperOwnProps {
+    /**
+     * Currently active step index (controlled). Not clamped: an out-of-range
+     * index renders every step completed (or inactive) with no active step.
+     */
+    active?: number;
+    /**
+     * Initially active step index (uncontrolled).
+     * @defaultValue 0
+     */
+    defaultActive?: number;
+    /** Fires with the new step index when the active step changes. */
+    onActiveChange?: (index: number) => void;
+    /**
+     * Fires on selectable step presses, and on the active step when pressed again,
+     * with the step's index and progress status. Disabled, non-clickable, and
+     * linear-blocked steps emit nothing.
+     */
+    onStepClick?: (detail: StepperStepClickDetail) => void;
+    /**
+     * Layout axis of the step list.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: StepperOrientation;
+    /**
+     * Display mode — indicators with connecting rails (`'default'`) or a progress
+     * border per step without rails (`'compact'`).
+     * @defaultValue 'default'
+     */
+    mode?: StepperMode;
+    /**
+     * Restricts navigation to a linear progression: any previous step, or the
+     * next step when the current one is neither errored nor disabled.
+     * @defaultValue false
+     */
+    linear?: boolean;
+    /**
+     * Density scale for indicators and typography.
+     * @defaultValue 'base'
+     */
+    size?: StepperSize;
+    /**
+     * Flips indicators and content along the cross axis.
+     * @defaultValue false
+     */
+    reverse?: boolean;
+    /**
+     * Accessible status suffix appended to a completed step's name — the check
+     * glyph alone is invisible to assistive technology. Localize per stepper;
+     * an empty string drops the suffix.
+     * @defaultValue 'completed'
+     */
+    completedLabel?: string;
+    /**
+     * Accessible status suffix appended to an errored step's name — the error
+     * glyph alone is invisible to assistive technology. Localize per stepper;
+     * an empty string drops the suffix.
+     * @defaultValue 'error'
+     */
+    errorLabel?: string;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<StepperSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<StepperSlot>;
+}
+/**
+ * Public props for the Stepper root. Children must be `Stepper.Item`
+ * elements — the root derives each step's index from its position in
+ * `children`. Arrays (e.g. `items.map(...)`) flatten into one index per
+ * item, but Fragments do not: items wrapped in `<>…</>` share a single
+ * index, so render items directly or from arrays.
+ *
+ * Wrapping `Stepper.Item` in an intermediary component keeps click gating
+ * correct, but first-paint/SSR gating reads `error`/`disabled`/`isClickable`
+ * off each direct child's props — forward them on the wrapper (or accept a
+ * one-paint `data-clickable`/`aria-disabled` correction after hydration).
+ *
+ * Arrow keys (following `orientation`), Home, and End move focus between
+ * step triggers; Tab still reaches every clickable step.
+ *
+ * Overriding `as` on the root leaves items rendering `<li>` — override the
+ * item's `as` in tandem to keep the markup valid.
+ */
+type StepperProps<T extends ElementType = 'ol'> = PolymorphicProps<'ol', T, StepperOwnProps>;
+interface StepperItemOwnProps {
+    /** Marks the step as errored without changing its progress status. */
+    error?: boolean;
+    /**
+     * Disables the step. The trigger renders as a natively disabled button:
+     * unfocusable, unselectable, and silent.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the step can be activated by pressing it. Non-clickable steps
+     * stay visible in the flow but are removed from the tab order.
+     * @defaultValue true
+     */
+    isClickable?: boolean;
+    /**
+     * Custom indicator content. Replaces the built-in status glyph (check,
+     * close, or dot) for every status except `disabled`. Pass a function to
+     * render by status — returning `undefined` or `null` falls back to the
+     * built-in glyphs, so numbered steps can surface the check once completed.
+     */
+    indicator?: ReactNode | ((state: StepperIndicatorState) => ReactNode);
+    /** Step content — typically `Stepper.Title` and `Stepper.Description`. */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<StepperItemSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<StepperItemSlot>;
+}
+type StepperItemProps<T extends ElementType = 'li'> = PolymorphicProps<'li', T, StepperItemOwnProps>;
+interface StepperTitleOwnProps {
+    /** Step title content. */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<StepperTitleSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<StepperTitleSlot>;
+}
+type StepperTitleProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, StepperTitleOwnProps>;
+interface StepperDescriptionOwnProps {
+    /** Step description content. */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<StepperDescriptionSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<StepperDescriptionSlot>;
+}
+type StepperDescriptionProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, StepperDescriptionOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Stepper: ComponentThemeConfig<StepperProps>;
+        StepperItem: ComponentThemeConfig<StepperItemProps, StepperItemSlot>;
+        StepperTitle: ComponentThemeConfig<StepperTitleProps>;
+        StepperDescription: ComponentThemeConfig<StepperDescriptionProps>;
+    }
+}
+
+declare const Stepper: {
+    <T extends react.ElementType = "ol">(props: StepperProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    Item: {
+        <T extends react.ElementType = "li">(props: StepperItemProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        <T extends react.ElementType = "span">(props: StepperTitleProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "span">(props: StepperDescriptionProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+};
+
+type SwitchSize = 'xlarge' | 'large' | 'base' | 'small' | 'xsmall';
+type SwitchVariant = 'info' | 'success';
+type SwitchSlot = 'root' | 'indicator' | 'thumb';
+/**
+ * Render props passed to the root `Switch` render-prop child. Re-exports
+ * Spar's shape verbatim — consumers reading the state inside compound
+ * children should use `Switch.Indicator` render-prop instead, which receives
+ * the takeoff-spar split via context.
+ */
+type SwitchRenderProps = SwitchRenderProps$1;
+/**
+ * Render props passed to `Switch.Indicator` function-children. Mirrors the
+ * shape used by `Checkbox.Indicator`.
+ */
+interface SwitchIndicatorRenderProps {
+    checked: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+}
+interface SwitchOwnProps {
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: SwitchSize;
+    /**
+     * Color variant used while checked.
+     * @defaultValue 'info'
+     */
+    variant?: SwitchVariant;
     /**
      * Marks the switch as visually invalid. When inside a `<Field>`, Spar
      * inherits the Field's invalid state automatically — pass this prop only
@@ -2582,4 +3544,507 @@ declare const Toast: {
     displayName: string;
 };
 
-export { Accordion, type AccordionContentProps, type AccordionCurrentValue, type AccordionHeaderProps, type AccordionHeadingLevel, type AccordionIndicatorProps, type AccordionIndicatorRenderState, type AccordionItemProps, type AccordionMode, type AccordionProps, type AccordionSize, type AccordionTriggerProps, type AccordionType, type AccordionValue, type AccordionValueChangeHandler, Alert, type AlertActionsProps, type AlertActionsSlot, type AlertAppearance, type AlertCloseProps, type AlertCloseSlot, type AlertContentProps, type AlertContentSlot, type AlertDescriptionProps, type AlertDescriptionSlot, type AlertProps, type AlertSlot, type AlertTitleProps, type AlertTitleSlot, type AlertVariant, Badge, type BadgeAppearance, type BadgeProps, type BadgeSize, type BadgeSlot, type BadgeVariant, Breadcrumb, type BreadcrumbItemProps, type BreadcrumbLinkProps, type BreadcrumbListProps, type BreadcrumbNavigationHandler, type BreadcrumbPageProps, type BreadcrumbPressEvent, type BreadcrumbProps, type BreadcrumbSeparatorProps, type BreadcrumbSeparatorVariant, type BreadcrumbSize, type BreadcrumbType, Button, type ButtonAppearance, type ButtonProps, type ButtonSize, type ButtonSlot, type ButtonVariant, Card, type CardBodyProps, type CardBodySlot, type CardDescriptionProps, type CardDescriptionSlot, type CardFooterProps, type CardFooterSlot, type CardFooterType, type CardHeaderProps, type CardHeaderSlot, type CardHeaderType, type CardProps, type CardSlot, type CardTitleProps, type CardTitleSlot, Checkbox, type CheckboxIndicatorProps, type CheckboxIndicatorRenderProps, type CheckboxProps, type CheckboxRenderProps, type CheckboxSize, type CheckboxSlot, Chip, type ChipAppearance, type ChipProps, type ChipSize, type ChipSlot, type ChipVariant, type ClassNamesMap, type ColorMode, type ComponentName, type ComponentThemeConfig, type ComponentThemeRegistry, type ComponentsThemeMap, type ControlledState, type DataSlotName, Dialog, type DialogBodyProps, type DialogBodySlot, type DialogCloseProps, type DialogCloseSlot, type DialogDescriptionProps, type DialogDescriptionSlot, type DialogFooterProps, type DialogFooterSlot, type DialogFooterType, type DialogHeaderProps, type DialogHeaderSlot, type DialogHeaderType, type DialogOverlayIntensity, type DialogOverlayProps, type DialogOverlaySlot, type DialogPanelProps, type DialogPanelSlot, type DialogProps, type DialogTitleProps, type DialogTitleSlot, type DialogTriggerProps, type DialogTriggerSlot, Drawer, type DrawerBodyProps, type DrawerCloseProps, type DrawerDescriptionProps, type DrawerFooterProps, type DrawerHeaderProps, type DrawerOverlayProps, type DrawerPanelProps, type DrawerPlacement, type DrawerProps, type DrawerTitleProps, type DrawerTriggerProps, Field, type FieldDescriptionProps, type FieldDescriptionSlot, type FieldErrorMessageProps, type FieldErrorMessageSlot, type FieldLabelProps, type FieldLabelSlot, type FieldProps, type FieldSlot, Input, type InputChipsProps, type InputChipsSlot, type InputClearButtonProps, type InputClearButtonSlot, type InputDecrementProps, type InputDecrementSlot, type InputFieldProps, type InputFieldSlot, type InputIncrementProps, type InputIncrementSlot, type InputLeadingIconProps, type InputLeadingIconSlot, type InputPrefixProps, type InputPrefixSlot, type InputProps, type InputRevealButtonProps, type InputRevealButtonSlot, type InputSize, type InputSlot, type InputSpinnerProps, type InputSpinnerSlot, type InputStepperProps, type InputStepperSlot, type InputStrengthProps, type InputStrengthSlot, type InputSuffixProps, type InputSuffixSlot, type InputTrailingIconProps, type InputTrailingIconSlot, Label, type LabelProps, type LabelSlot, Popover, type PopoverArrowProps, type PopoverArrowSlot, type PopoverCloseProps, type PopoverCloseSlot, type PopoverContentProps, type PopoverContentSlot, type PopoverDescriptionProps, type PopoverDescriptionSlot, type PopoverHeaderProps, type PopoverHeaderSlot, type PopoverProps, type PopoverTriggerProps, type PopoverTriggerSlot, type PopoverVariant, Radio, type RadioIndicatorProps, type RadioItemProps, type RadioItemSlot, type RadioLabelProps, type RadioPosition, type RadioProps, type RadioRenderProps, type RadioSize, type RadioSlot, Select, type SelectContentProps, type SelectGroupProps, type SelectIndicatorProps, type SelectIndicatorRenderState, type SelectItemProps, type SelectLabelProps, type SelectProps, type SelectSeparatorProps, type SelectSize, type SelectTriggerProps, type SlotClassNames, type SlotPropsMap, Spinner, type SpinnerAppearance, type SpinnerProps, type SpinnerSize, type SpinnerSlot, type SpinnerVariant, type StateOnlyComponentThemeConfig$1 as StateOnlyComponentThemeConfig, Switch, type SwitchIndicatorProps, type SwitchIndicatorRenderProps, type SwitchProps, type SwitchRenderProps, type SwitchSize, type SwitchSlot, type SwitchVariant, Table, type TableAlign, type TableColumnAccessor, type TableColumnDef, type TableColumnFilter, type TableColumnFilterContext, type TableColumnFilterOption, type TableColumnFilterType, type TableColumnMeta, type TableDataRequest, type TableExpansionConfig, type TableFilteringConfig, type TablePaginationConfig, type TableProps, type TableSelectionConfig, type TableSize, type TableSlot, type TableSortingConfig, type TableStickySide, Tabs, type TabsActivationMode, type TabsAppearance, type TabsContentProps, type TabsListProps, type TabsProps, type TabsSize, type TabsTriggerProps, type TabsTriggerRenderProps, type TabsVariant, TakeoffSparProvider, type TakeoffSparProviderProps, type TakeoffSparProviderValue, type ThemeValue, Toast, type ToastAppearance, type ToastData, type ToastOptions, type ToastProps, type ToastSlot, type ToastVariant, Toaster, type ToasterOwnProps, type ToasterProps, type ToasterSlot, Tooltip, type TooltipArrowProps, type TooltipArrowSlot, type TooltipContentProps, type TooltipContentSlot, type TooltipDescriptionProps, type TooltipDescriptionSlot, type TooltipHeaderProps, type TooltipHeaderSlot, type TooltipProps, type TooltipProviderProps, type TooltipTriggerProps, type TooltipTriggerSlot, type TooltipVariant, getExportRows, useComponentTheme, useTheme };
+type SkeletonShape = 'rectangle' | 'circle';
+type SkeletonAnimation = 'shimmer' | 'none';
+type SkeletonSlot = 'root' | 'shimmer';
+interface SkeletonProps extends Omit<TakeoffHTMLProps<'span'>, 'children'> {
+    /**
+     * Placeholder silhouette. `rectangle` renders the rounded bar, `circle`
+     * a full-radius disc whose diameter tracks `height`.
+     * @defaultValue 'rectangle'
+     */
+    shape?: SkeletonShape;
+    /**
+     * Loading animation. `shimmer` sweeps the highlight strip across the bar;
+     * `none` renders a static placeholder.
+     * @defaultValue 'shimmer'
+     */
+    animation?: SkeletonAnimation;
+    /**
+     * Fixed width, number in px or any CSS length. Published to the recipe as
+     * `--tk-skeleton-width`; defaults to filling the container.
+     */
+    width?: number | string;
+    /**
+     * Fixed height, number in px or any CSS length. Published to the recipe as
+     * `--tk-skeleton-height`.
+     */
+    height?: number | string;
+    /** Ref forwarded to the root span element. */
+    ref?: Ref<HTMLSpanElement>;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<SkeletonSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<SkeletonSlot>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Skeleton: ComponentThemeConfig<SkeletonProps, SkeletonSlot>;
+    }
+}
+
+declare const Skeleton: {
+    (props: SkeletonProps): react.JSX.Element;
+    displayName: string;
+};
+
+type UploadSlot = 'root';
+type UploadDropzoneSlot = 'root';
+type UploadActionsSlot = 'root';
+type UploadTriggerSlot = 'root';
+type UploadSubmitSlot = 'root';
+type UploadListSlot = 'root';
+type UploadItemSlot = 'root';
+type UploadItemContentSlot = 'root' | 'name' | 'size' | 'status' | 'progress';
+type UploadItemPreviewSlot = 'root' | 'image' | 'icon' | 'extension';
+type UploadItemActionsSlot = 'root';
+type UploadItemActionSlot = 'root';
+/**
+ * Per-file lifecycle status, driven by the consumer (the component does not
+ * upload): `'idle'` is the resting state, `'uploading'` the transfer itself (the
+ * only status that draws the progress bar), `'processing'` the server's own step
+ * once the bytes have landed, which reports no percentage, and `'completed'` /
+ * `'error'` the two outcomes.
+ */
+type UploadFileStatus = 'idle' | 'uploading' | 'processing' | 'completed' | 'error';
+/**
+ * A file in the Upload value: a plain object that *points at* a picked `File`,
+ * or stands for a remote/preloaded one through its `url`. `name` / `size` /
+ * `type` may be set on the entry or read off `file`; the entry's own value
+ * always wins.
+ */
+interface UploadFile {
+    /** Stable identity (React key, status mapping). Generated for picked files. */
+    id: string;
+    /** The local bytes. Absent for a remote/preloaded entry, which uses `url`. */
+    file?: File;
+    /** Display name. Read off `file` when the entry does not state it. */
+    name?: string;
+    /** Size in bytes. Read off `file` when the entry does not state it. */
+    size?: number;
+    /** MIME type. Read off `file` when the entry does not state it. */
+    type?: string;
+    /** Remote URL for download / image preview when the bytes are not local. */
+    url?: string;
+    /**
+     * A picture *of* the file rather than the file itself — a server-rendered
+     * first page, a video's poster frame. Shown whatever the entry's `type` is,
+     * which is what puts a non-image on the image branch; the download ignores it.
+     */
+    thumbUrl?: string;
+    /**
+     * Lifecycle status. Optional because an entry without one already means the
+     * resting state.
+     * @defaultValue 'idle'
+     */
+    status?: UploadFileStatus;
+    /** Upload progress 0–100 while `status` is `'uploading'`. */
+    progress?: number;
+    /** Human-readable error, shown when `status` is `'error'`. */
+    error?: string;
+}
+/**
+ * A file that failed validation, emitted (batched) through `onFilesReject` —
+ * rejected files never enter `value`, so this is the only way a consumer learns
+ * about them. Discriminated on `code`, and each branch carries the limit that
+ * was broken, since the sentence shown to the user is the consumer's to write.
+ */
+type UploadRejection = {
+    file: File;
+    code: 'file-invalid-type';
+    /** The `accept` list the file failed to match. */
+    accept: string;
+} | {
+    file: File;
+    code: 'file-too-large';
+    /** The `maxFileSize` (bytes) the file exceeded. */
+    maxFileSize: number;
+} | {
+    file: File;
+    code: 'too-many-files';
+    /** How many files were allowed — `maxFileCount`, or 1 without `multiple`. */
+    maxFileCount: number;
+};
+/**
+ * State + validation props owned by the Upload root. The anatomy — dropzone,
+ * trigger, per-file actions — is expressed by composing parts rather than by
+ * flags, mirroring the Input "modes as composition" model.
+ */
+interface UploadOwnProps {
+    /** Committed files (controlled). Pair with `onValueChange`. */
+    value?: UploadFile[];
+    /** Initial files for uncontrolled usage. */
+    defaultValue?: UploadFile[];
+    /** Called with the next file array after a selection, drop, or removal. */
+    onValueChange?: (files: UploadFile[]) => void;
+    /** Acceptable file types — comma-separated MIME types (`image/*`) and/or extensions (`.pdf`). */
+    accept?: string;
+    /**
+     * Allow selecting/holding more than one file. When `false`, a new selection
+     * replaces the current file.
+     * @defaultValue false
+     */
+    multiple?: boolean;
+    /**
+     * Browse folders instead of single files: the picker takes a directory and
+     * every file inside it (recursively), each keeping its `webkitRelativePath`
+     * (e.g. `reports/2024/q1.pdf`) for rebuilding the tree. Implies `multiple`.
+     * Only affects the picker — dropping a folder on `Upload.Dropzone` does not
+     * expand it.
+     * @defaultValue false
+     */
+    directory?: boolean;
+    /** Maximum size per file, in bytes. Larger files are rejected. */
+    maxFileSize?: number;
+    /** Maximum number of files (only meaningful with `multiple`). Extra files are rejected. */
+    maxFileCount?: number;
+    /**
+     * Called with the entries that just entered the value — the files wrapped this
+     * batch rather than the whole array, which is what a consumer starts its own
+     * upload from. Files dropped as duplicates of ones already held are not
+     * reported.
+     */
+    onFileAccept?: (files: UploadFile[]) => void;
+    /** Called with every file rejected by validation (type, size, or count). */
+    onFilesReject?: (rejections: UploadRejection[]) => void;
+    /**
+     * Row support text while a file transfers. Localize per upload; an empty
+     * string drops the status line, glyph included.
+     * @defaultValue 'Uploading…'
+     */
+    uploadingLabel?: string;
+    /**
+     * Row support text while the server works on a file that has landed.
+     * Localize per upload; an empty string drops the status line, glyph included.
+     * @defaultValue 'Processing…'
+     */
+    processingLabel?: string;
+    /**
+     * Row support text once a file is done. Localize per upload; an empty string
+     * drops the status line, glyph included.
+     * @defaultValue 'Completed'
+     */
+    completedLabel?: string;
+    /**
+     * Row support text for a failure that reports no `error` message of its own —
+     * an entry's own `error` always wins. Localize per upload; an empty string
+     * drops the status line, glyph included.
+     * @defaultValue 'Failed'
+     */
+    errorLabel?: string;
+    /**
+     * Accessible name for a row's progress bar, as a template: `{name}` stands
+     * for the file's name, so several bars uploading at once stay distinguishable.
+     * An empty string counts as unset — the bar cannot go unnamed.
+     * @defaultValue '{name} upload progress'
+     */
+    progressLabel?: string;
+    /**
+     * Accessible name for the built-in `action="download"`, as a `{name}`
+     * template. An `Upload.ItemAction`'s own `label` wins over it, and an empty
+     * string counts as unset — an icon-only button cannot go unnamed.
+     * @defaultValue 'Download {name}'
+     */
+    downloadLabel?: string;
+    /**
+     * Accessible name for the built-in `action="remove"`, as a `{name}` template.
+     * An `Upload.ItemAction`'s own `label` wins over it, and an empty string
+     * counts as unset — an icon-only button cannot go unnamed.
+     * @defaultValue 'Remove {name}'
+     */
+    removeLabel?: string;
+    /** Disables the whole control. Also inherited from a surrounding `Field`. */
+    disabled?: boolean;
+    /** Read-only: files render and remain downloadable, but adding/removing is blocked. Also inherited from `Field`. */
+    readOnly?: boolean;
+    /** Marks the control invalid — mirrored as `data-invalid` for the recipe's danger styling. Also inherited from `Field`. */
+    invalid?: boolean;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<UploadSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<UploadSlot>;
+}
+/** Public props for the Upload root. Polymorphic via `as` (default `div`). */
+type UploadProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadOwnProps>;
+interface UploadDropzoneOwnProps {
+    /** Zone content — typically a prompt and an `Upload.Trigger`. */
+    children?: ReactNode;
+    classNames?: ClassNamesMap<UploadDropzoneSlot>;
+    slotProps?: SlotPropsMap<UploadDropzoneSlot>;
+}
+/**
+ * Drag-and-drop target. Composing it is what enables drag-and-drop; it owns the
+ * `data-drag-state` (`accept` | `reject`) styling hook while a payload hovers.
+ */
+type UploadDropzoneProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadDropzoneOwnProps>;
+interface UploadActionsOwnProps {
+    /** The controls to put on one line — typically `Upload.Trigger` and `Upload.Submit`. */
+    children?: ReactNode;
+    classNames?: ClassNamesMap<UploadActionsSlot>;
+    slotProps?: SlotPropsMap<UploadActionsSlot>;
+}
+/**
+ * A row for controls that belong together. `Upload.Dropzone` stacks its
+ * children, so a Browse button and a Send button written as bare siblings each
+ * take a line of their own; wrapping them in this part puts them side by side.
+ * It holds no behavior — anywhere a set of controls should share a line, this is
+ * the box for it.
+ */
+type UploadActionsProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadActionsOwnProps>;
+interface UploadTriggerOwnProps {
+    /** Trigger label (e.g. `"Choose file"`). */
+    children?: ReactNode;
+    /**
+     * Button appearance. Quieter than Button's own default, and the treatment
+     * `Upload.Submit` takes too — the two stand beside each other in the zone, so
+     * they read as one pair. Re-point it on a Trigger that stands alone.
+     * @defaultValue 'outlined'
+     */
+    appearance?: ButtonAppearance;
+    /**
+     * Button color variant.
+     * @defaultValue 'neutral'
+     */
+    variant?: ButtonVariant;
+    classNames?: ClassNamesMap<UploadTriggerSlot>;
+    slotProps?: SlotPropsMap<UploadTriggerSlot>;
+}
+/** Button that opens the native file picker. Focusable; disabled when the upload is disabled or read-only. */
+type UploadTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, UploadTriggerOwnProps>;
+interface UploadSubmitOwnProps {
+    /** Submit label (e.g. `"Upload"`). Wire the actual upload through `onClick`. */
+    children?: ReactNode;
+    /**
+     * Button appearance. The Trigger's, not Button's own: the two stand beside
+     * each other in the zone, so they read as one pair rather than as two weights.
+     * Re-point it where the send is the page's primary action.
+     * @defaultValue 'outlined'
+     */
+    appearance?: ButtonAppearance;
+    /**
+     * Button color variant.
+     * @defaultValue 'neutral'
+     */
+    variant?: ButtonVariant;
+    classNames?: ClassNamesMap<UploadSubmitSlot>;
+    slotProps?: SlotPropsMap<UploadSubmitSlot>;
+}
+/**
+ * Optional "upload" button. The component does not perform the network upload
+ * (out of scope) — wire it through `onClick`. Disabled while there are no files
+ * or when the upload is disabled; read-only leaves it working, since handing a
+ * fixed list upstream does not change it.
+ */
+type UploadSubmitProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, UploadSubmitOwnProps>;
+interface UploadListOwnProps {
+    /**
+     * The rows. A function receives the current files and returns them (the usual
+     * form — the consumer owns the map, so each `Upload.Item` gets its `file` and
+     * every action closes over it). Plain nodes are rendered as authored. Omit it
+     * for a default `Upload.Item` per file.
+     */
+    children?: ReactNode | ((files: UploadFile[]) => ReactNode);
+    classNames?: ClassNamesMap<UploadListSlot>;
+    slotProps?: SlotPropsMap<UploadListSlot>;
+}
+/**
+ * File list region. Renders nothing while empty; otherwise its children (or a
+ * default row per file).
+ */
+type UploadListProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadListOwnProps>;
+interface UploadItemOwnProps {
+    /** The file this row renders. Also what its `Upload.ItemAction` children read. */
+    file: UploadFile;
+    /**
+     * Action controls (`Upload.ItemAction`), wrapped in a default
+     * `Upload.ItemActions` for you — and *replacing* its default download + remove
+     * pair rather than joining it. Composing `Upload.ItemPreview`,
+     * `Upload.ItemContent`, or `Upload.ItemActions` replaces that region instead,
+     * each hoisted into its own position wherever it is written; with an
+     * `Upload.ItemActions` composed, anything else stays where it was written.
+     */
+    children?: ReactNode;
+    classNames?: ClassNamesMap<UploadItemSlot>;
+    slotProps?: SlotPropsMap<UploadItemSlot>;
+}
+/**
+ * Per-file row, in three regions: preview · content · actions. Every region has
+ * a default, so a bare row with only `file` is complete. Mirrors the entry's
+ * `status` as `data-status`.
+ */
+type UploadItemProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadItemOwnProps>;
+interface UploadItemContentOwnProps {
+    /**
+     * Replaces the file's details entirely — your own name/meta layout, a
+     * description line, an inline error. Omit it for the default content (name,
+     * size, status icon, and the progress bar while uploading).
+     */
+    children?: ReactNode;
+    classNames?: ClassNamesMap<UploadItemContentSlot>;
+    slotProps?: SlotPropsMap<UploadItemContentSlot>;
+}
+/**
+ * The row's middle region: the file's name, its formatted size, the status icon
+ * (spinner / check / warning), and the progress bar while the entry uploads —
+ * all decorative inline slots of this part, styled through `classNames` /
+ * `slotProps`. `Upload.Item` renders it by default, and it reads its file from
+ * the surrounding row.
+ */
+type UploadItemContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadItemContentOwnProps>;
+/**
+ * Per-slot attribute overrides for the preview. The `image` slot renders an
+ * `<img>`, so it also accepts image attributes (`alt`, `loading`, `sizes`, …) —
+ * the part's own `alt=""` / `loading="lazy"` are defaults a call site can
+ * replace, not invariants.
+ */
+type UploadItemPreviewSlotProps = SlotPropsMap<UploadItemPreviewSlot> & {
+    image?: ImgHTMLAttributes<HTMLImageElement>;
+};
+interface UploadItemPreviewOwnProps {
+    /**
+     * Replaces the built-in thumbnail entirely — your own glyph, a video poster,
+     * a rendered document page. Omit it for the default preview (image thumbnail,
+     * file-type icon, or extension badge).
+     */
+    children?: ReactNode;
+    classNames?: ClassNamesMap<UploadItemPreviewSlot>;
+    slotProps?: UploadItemPreviewSlotProps;
+}
+/**
+ * The row's thumbnail, in three branches: an image preview for image entries (a
+ * local `File` through an object URL revoked on unmount/change, a remote entry
+ * through its `url`), the shipped file-type icon (PDF, Word, Excel, PowerPoint,
+ * JPG, PNG, MP4, TXT, ZIP), and the uppercased extension for everything else.
+ * `Upload.Item` renders it by default, and it reads its file from the
+ * surrounding row.
+ */
+type UploadItemPreviewProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, UploadItemPreviewOwnProps>;
+interface UploadItemActionsOwnProps {
+    /**
+     * The row's actions. Replaces the default pair (`download` + `remove`)
+     * entirely — pass the `Upload.ItemAction`s you want, in the order you want.
+     */
+    children?: ReactNode;
+    classNames?: ClassNamesMap<UploadItemActionsSlot>;
+    slotProps?: SlotPropsMap<UploadItemActionsSlot>;
+}
+/**
+ * The row's trailing action area. `Upload.Item` renders it by default — holding
+ * a download and a remove action — so it only needs composing to change that set
+ * or to style / move the container itself.
+ */
+type UploadItemActionsProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, UploadItemActionsOwnProps>;
+interface UploadItemActionOwnProps {
+    /**
+     * Names the action, mirrored as `data-action` whatever the name is.
+     *
+     * Two names arrive wired, each with its own icon and label: `'download'` saves
+     * the row's file (its `File` through an object URL, a preloaded entry through
+     * its `url`) and stays available in read-only; `'remove'` drops the file from
+     * `value` and is not rendered at all in read-only. Any other name —
+     * `'preview'`, `'retry'`, `'share'` — is yours: the behavior comes from
+     * `onClick`, the glyph from `children`, the wording from `label`.
+     */
+    action?: 'download' | 'remove' | (string & {});
+    /**
+     * Accessible name for the action, as a template: `{name}` stands for the
+     * file's name, so `"Preview {name}"` gives `aria-label="Preview report.pdf"`
+     * and icon-only actions stay labelled per file. An explicit `aria-label` wins
+     * over it, and an empty one counts as unset, so a built-in action falls back
+     * to the root's copy rather than losing its name.
+     * @defaultValue the root's copy for the `action` (`downloadLabel` / `removeLabel`)
+     */
+    label?: string;
+    /** Action content — typically an icon. Defaults to the `action`'s own glyph. */
+    children?: ReactNode;
+    /**
+     * Button appearance. Defaults to the row's shape — a small, quiet icon button
+     * beside the file's details — rather than Button's own default, so a text-only
+     * remove or a danger-coloured one is a re-point, not a rebuild.
+     * @defaultValue 'outlined'
+     */
+    appearance?: ButtonAppearance;
+    /**
+     * Button color variant.
+     * @defaultValue 'neutral'
+     */
+    variant?: ButtonVariant;
+    /**
+     * Button size scale.
+     * @defaultValue 'small'
+     */
+    size?: ButtonSize;
+    classNames?: ClassNamesMap<UploadItemActionSlot>;
+    slotProps?: SlotPropsMap<UploadItemActionSlot>;
+}
+/**
+ * Per-file action control: one focusable, file-labelled button covering the
+ * built-in download / remove and every consumer-wired action — preview, retry,
+ * share — through `onClick`. Rendering it as `as="a" href` hands the download to
+ * the platform instead. Inert when the upload is disabled, or when the call site
+ * disables this one action.
+ */
+type UploadItemActionProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, UploadItemActionOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Upload: ComponentThemeConfig<UploadProps, UploadSlot>;
+        UploadDropzone: ComponentThemeConfig<UploadDropzoneProps, UploadDropzoneSlot>;
+        UploadActions: ComponentThemeConfig<UploadActionsProps, UploadActionsSlot>;
+        UploadTrigger: ComponentThemeConfig<UploadTriggerProps, UploadTriggerSlot>;
+        UploadSubmit: ComponentThemeConfig<UploadSubmitProps, UploadSubmitSlot>;
+        UploadList: ComponentThemeConfig<UploadListProps, UploadListSlot>;
+        UploadItem: ComponentThemeConfig<UploadItemProps, UploadItemSlot>;
+        UploadItemContent: ComponentThemeConfig<UploadItemContentProps, UploadItemContentSlot>;
+        UploadItemPreview: ComponentThemeConfig<UploadItemPreviewProps, UploadItemPreviewSlot, UploadItemPreviewSlotProps>;
+        UploadItemActions: ComponentThemeConfig<UploadItemActionsProps, UploadItemActionsSlot>;
+        UploadItemAction: ComponentThemeConfig<UploadItemActionProps, UploadItemActionSlot>;
+    }
+}
+
+declare const Upload: {
+    <T extends react.ElementType = "div">(props: UploadProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    Dropzone: {
+        <T extends react.ElementType = "div">(props: UploadDropzoneProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Actions: {
+        <T extends react.ElementType = "div">(props: UploadActionsProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Trigger: {
+        <T extends react.ElementType = "button">(props: UploadTriggerProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Submit: {
+        <T extends react.ElementType = "button">(props: UploadSubmitProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    List: {
+        <T extends react.ElementType = "div">(props: UploadListProps<T>): react.JSX.Element | null;
+        displayName: string;
+    };
+    Item: {
+        <T extends react.ElementType = "div">(props: UploadItemProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    ItemPreview: {
+        <T extends react.ElementType = "span">(props: UploadItemPreviewProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    ItemContent: {
+        <T extends react.ElementType = "div">(props: UploadItemContentProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    ItemActions: {
+        <T extends react.ElementType = "div">(props: UploadItemActionsProps<T>): react.JSX.Element | null;
+        displayName: string;
+    };
+    ItemAction: {
+        <T extends react.ElementType = "button">(props: UploadItemActionProps<T>): react.JSX.Element | null;
+        displayName: string;
+    };
+};
+
+export { Accordion, type AccordionContentProps, type AccordionCurrentValue, type AccordionHeaderProps, type AccordionHeadingLevel, type AccordionIndicatorProps, type AccordionIndicatorRenderState, type AccordionItemProps, type AccordionMode, type AccordionProps, type AccordionSize, type AccordionTriggerProps, type AccordionType, type AccordionValue, type AccordionValueChangeHandler, Alert, type AlertActionsProps, type AlertActionsSlot, type AlertAppearance, type AlertCloseProps, type AlertCloseSlot, type AlertContentProps, type AlertContentSlot, type AlertDescriptionProps, type AlertDescriptionSlot, type AlertProps, type AlertSlot, type AlertTitleProps, type AlertTitleSlot, type AlertVariant, Badge, type BadgeAppearance, type BadgeProps, type BadgeSize, type BadgeSlot, type BadgeVariant, Breadcrumb, type BreadcrumbItemProps, type BreadcrumbLinkProps, type BreadcrumbListProps, type BreadcrumbNavigationHandler, type BreadcrumbPageProps, type BreadcrumbPressEvent, type BreadcrumbProps, type BreadcrumbSeparatorProps, type BreadcrumbSize, type BreadcrumbType, Button, type ButtonAppearance, type ButtonProps, type ButtonSize, type ButtonSlot, type ButtonVariant, Card, type CardBodyProps, type CardBodySlot, type CardDescriptionProps, type CardDescriptionSlot, type CardFooterProps, type CardFooterSlot, type CardFooterType, type CardHeaderProps, type CardHeaderSlot, type CardHeaderType, type CardProps, type CardSlot, type CardTitleProps, type CardTitleSlot, Checkbox, type CheckboxIndicatorProps, type CheckboxIndicatorRenderProps, type CheckboxProps, type CheckboxRenderProps, type CheckboxSize, type CheckboxSlot, Chip, type ChipAppearance, type ChipProps, type ChipSize, type ChipSlot, type ChipVariant, type ClassNamesMap, type ColorMode, type ComponentName, type ComponentThemeConfig, type ComponentThemeRegistry, type ComponentsThemeMap, type ControlledState, type DataSlotName, Dialog, type DialogBodyProps, type DialogBodySlot, type DialogCloseProps, type DialogCloseSlot, type DialogDescriptionProps, type DialogDescriptionSlot, type DialogFooterProps, type DialogFooterSlot, type DialogFooterType, type DialogHeaderProps, type DialogHeaderSlot, type DialogHeaderType, type DialogOverlayIntensity, type DialogOverlayProps, type DialogOverlaySlot, type DialogPanelProps, type DialogPanelSlot, type DialogProps, type DialogTitleProps, type DialogTitleSlot, type DialogTriggerProps, type DialogTriggerSlot, Divider, type DividerAlign, type DividerAppearance, type DividerOrientation, type DividerProps, type DividerSlot, Drawer, type DrawerBodyProps, type DrawerCloseProps, type DrawerDescriptionProps, type DrawerFooterProps, type DrawerHeaderProps, type DrawerOverlayProps, type DrawerPanelProps, type DrawerPlacement, type DrawerProps, type DrawerTitleProps, type DrawerTriggerProps, Dropdown, type DropdownArrowProps, type DropdownContentProps, type DropdownContentWidth, type DropdownGroupProps, type DropdownItemProps, type DropdownLabelProps, type DropdownProps, type DropdownSeparatorProps, type DropdownSize, type DropdownTriggerProps, type DropdownViewportProps, Field, type FieldDescriptionProps, type FieldDescriptionSlot, type FieldErrorMessageProps, type FieldErrorMessageSlot, type FieldLabelProps, type FieldLabelSlot, type FieldProps, type FieldSlot, Input, type InputChipsProps, type InputChipsSlot, type InputClearButtonProps, type InputClearButtonSlot, type InputDecrementProps, type InputDecrementSlot, type InputFieldProps, type InputFieldSlot, type InputIncrementProps, type InputIncrementSlot, type InputLeadingIconProps, type InputLeadingIconSlot, type InputPrefixProps, type InputPrefixSlot, type InputProps, type InputRevealButtonProps, type InputRevealButtonSlot, type InputSize, type InputSlot, type InputSpinnerProps, type InputSpinnerSlot, type InputStepperProps, type InputStepperSlot, type InputStrengthProps, type InputStrengthSlot, type InputSuffixProps, type InputSuffixSlot, type InputTrailingIconProps, type InputTrailingIconSlot, Label, type LabelProps, type LabelSlot, Popover, type PopoverArrowProps, type PopoverArrowSlot, type PopoverCloseProps, type PopoverCloseSlot, type PopoverContentProps, type PopoverContentSlot, type PopoverDescriptionProps, type PopoverDescriptionSlot, type PopoverHeaderProps, type PopoverHeaderSlot, type PopoverProps, type PopoverTriggerProps, type PopoverTriggerSlot, type PopoverVariant, Progress, type ProgressAppearance, type ProgressIndicatorProps, type ProgressIndicatorSlot, type ProgressProps, type ProgressSize, type ProgressSlot, type ProgressTrackProps, type ProgressTrackSlot, type ProgressValueProps, type ProgressValueSlot, type ProgressVariant, Radio, type RadioIndicatorProps, type RadioItemProps, type RadioItemSlot, type RadioLabelProps, type RadioPosition, type RadioProps, type RadioRenderProps, type RadioSize, type RadioSlot, Select, type SelectArrowProps, type SelectContentProps, type SelectGroupProps, type SelectIndicatorProps, type SelectIndicatorRenderState, type SelectItemProps, type SelectLabelProps, type SelectProps, type SelectSeparatorProps, type SelectSize, type SelectTriggerProps, type SelectViewportProps, Skeleton, type SkeletonAnimation, type SkeletonProps, type SkeletonShape, type SkeletonSlot, Slider, type SliderOrientation, type SliderProps, type SliderRangeProps, type SliderRangeValueProps, type SliderSingleValueProps, type SliderSize, type SliderSlot, type SliderThumbProps, type SliderThumbRenderProps, type SliderTicksProps, type SliderTooltip, type SliderTrackMode, type SliderTrackProps, type SliderValue, type SliderValueProps, type SliderValueRenderProps, type SliderVariant, type SlotClassNames, type SlotPropsMap, Spinner, type SpinnerAppearance, type SpinnerProps, type SpinnerSize, type SpinnerSlot, type SpinnerVariant, type StateOnlyComponentThemeConfig$1 as StateOnlyComponentThemeConfig, Stepper, type StepperDescriptionProps, type StepperIndicatorState, type StepperItemProps, type StepperMode, type StepperOrientation, type StepperProps, type StepperSize, type StepperStepClickDetail, type StepperStepStatus, type StepperTitleProps, Switch, type SwitchIndicatorProps, type SwitchIndicatorRenderProps, type SwitchProps, type SwitchRenderProps, type SwitchSize, type SwitchSlot, type SwitchVariant, Table, type TableAlign, type TableColumnAccessor, type TableColumnDef, type TableColumnFilter, type TableColumnFilterContext, type TableColumnFilterOption, type TableColumnFilterType, type TableColumnMeta, type TableDataRequest, type TableExpansionConfig, type TableFilteringConfig, type TablePaginationConfig, type TableProps, type TableSelectionConfig, type TableSize, type TableSlot, type TableSortingConfig, type TableStickySide, Tabs, type TabsActivationMode, type TabsAppearance, type TabsContentProps, type TabsListProps, type TabsProps, type TabsSize, type TabsTriggerProps, type TabsTriggerRenderProps, type TabsVariant, TakeoffSparProvider, type TakeoffSparProviderProps, type TakeoffSparProviderValue, type ThemeValue, Toast, type ToastAppearance, type ToastData, type ToastOptions, type ToastProps, type ToastSlot, type ToastVariant, Toaster, type ToasterOwnProps, type ToasterProps, type ToasterSlot, Tooltip, type TooltipArrowProps, type TooltipArrowSlot, type TooltipContentProps, type TooltipContentSlot, type TooltipDescriptionProps, type TooltipDescriptionSlot, type TooltipHeaderProps, type TooltipHeaderSlot, type TooltipProps, type TooltipProviderProps, type TooltipTriggerProps, type TooltipTriggerSlot, type TooltipVariant, Upload, type UploadActionsProps, type UploadActionsSlot, type UploadDropzoneProps, type UploadDropzoneSlot, type UploadFile, type UploadFileStatus, type UploadItemActionProps, type UploadItemActionSlot, type UploadItemActionsProps, type UploadItemActionsSlot, type UploadItemContentProps, type UploadItemContentSlot, type UploadItemPreviewProps, type UploadItemPreviewSlot, type UploadItemPreviewSlotProps, type UploadItemProps, type UploadItemSlot, type UploadListProps, type UploadListSlot, type UploadProps, type UploadRejection, type UploadSlot, type UploadSubmitProps, type UploadSubmitSlot, type UploadTriggerProps, type UploadTriggerSlot, getExportRows, useComponentTheme, useTheme };