@takeoff-ui/react-spar 0.1.2 → 0.3.0

package/dist/index.d.cts

@@ -1,7 +1,9 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
 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, ButtonProps as ButtonProps$1, CheckboxRenderProps as CheckboxRenderProps$1, CheckboxProps as CheckboxProps$1, DialogProps, DialogTriggerProps, DialogOverlayProps, DialogContentProps, DialogTitleProps, DialogCloseProps, FieldProps as FieldProps$1, FieldLabelProps as FieldLabelProps$1, FieldDescriptionProps as FieldDescriptionProps$1, FieldErrorMessageProps as FieldErrorMessageProps$1, InputProps as InputProps$1, InputFieldProps as InputFieldProps$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, TooltipTriggerProps as TooltipTriggerProps$1, TooltipContentProps as TooltipContentProps$1, TooltipProps as TooltipProps$1, TooltipProviderProps as TooltipProviderProps$1 } from '@turkish-technology/spar';
+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';
 
 /** Per-slot class map declared by a component base. Every slot is required. */
 type SlotClassNames<TSlot extends string> = Record<TSlot, string>;
@@ -101,7 +103,7 @@ interface TakeoffSparProviderProps extends Partial<TakeoffSparProviderValue> {
  * script that reads stored preferences) to avoid a first-paint flash before
  * the provider's effect runs.
  */
-declare const TakeoffSparProvider: ({ children, colorMode, locale, components }: TakeoffSparProviderProps) => react_jsx_runtime.JSX.Element;
+declare const TakeoffSparProvider: ({ children, colorMode, locale, components }: TakeoffSparProviderProps) => react.JSX.Element;
 /**
  * Read the active theme value. The provider is **optional**: when no
  * `TakeoffSparProvider` ancestor is present, the default theme
@@ -247,32 +249,136 @@ declare module '../../core/theme' {
 }
 
 declare const Accordion: {
-    <T extends react.ElementType = "div">(props: AccordionProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends react.ElementType = "div">(props: AccordionProps<T>): react.JSX.Element;
     displayName: string;
 } & {
     Item: {
-        <T extends react.ElementType = "div">(props: AccordionItemProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: AccordionItemProps<T>): react.JSX.Element;
         displayName: string;
     };
     Header: {
-        <T extends react.ElementType = "h3">(props: AccordionHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "h3">(props: AccordionHeaderProps<T>): react.JSX.Element;
         displayName: string;
     };
     Trigger: {
-        <T extends react.ElementType = "button">(props: AccordionTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "button">(props: AccordionTriggerProps<T>): react.JSX.Element;
         displayName: string;
     };
     Indicator: {
-        <T extends react.ElementType = "span">(props: AccordionIndicatorProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "span">(props: AccordionIndicatorProps<T>): react.JSX.Element;
         displayName: string;
     };
     Content: {
-        <T extends react.ElementType = "div">(props: AccordionContentProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: AccordionContentProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
-type BadgeVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning' | 'verified' | 'purple' | 'cyan' | 'business';
+type AlertVariant = 'success' | 'warning' | 'info' | 'danger' | 'neutral';
+type AlertAppearance = 'filled' | 'filledLight' | 'outlined' | 'gradient';
+type AlertSlot = 'root';
+type AlertContentSlot = 'root';
+type AlertTitleSlot = 'root';
+type AlertDescriptionSlot = 'root';
+type AlertActionsSlot = 'root';
+type AlertCloseSlot = 'root';
+interface AlertOwnProps {
+    /**
+     * Defines the visual variant of the alert.
+     * @defaultValue 'neutral'
+     */
+    variant?: AlertVariant;
+    /**
+     * Visual appearance of the alert.
+     * @defaultValue 'filled'
+     */
+    appearance?: AlertAppearance;
+    /** Called when `Alert.Close` is clicked. */
+    onClose?: () => void;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<AlertSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<AlertSlot>;
+}
+type AlertProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, AlertOwnProps>;
+interface AlertContentOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<AlertContentSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<AlertContentSlot>;
+}
+type AlertContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, AlertContentOwnProps>;
+interface AlertTitleOwnProps {
+    /**
+     * Semantic heading level used when `as` is not provided.
+     * @defaultValue 5
+     */
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<AlertTitleSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<AlertTitleSlot>;
+}
+type AlertTitleProps<T extends ElementType = 'h5'> = PolymorphicProps<'h5', T, AlertTitleOwnProps>;
+interface AlertDescriptionOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<AlertDescriptionSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<AlertDescriptionSlot>;
+}
+type AlertDescriptionProps<T extends ElementType = 'p'> = PolymorphicProps<'p', T, AlertDescriptionOwnProps>;
+interface AlertActionsOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<AlertActionsSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<AlertActionsSlot>;
+}
+type AlertActionsProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, AlertActionsOwnProps>;
+interface AlertCloseOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<AlertCloseSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<AlertCloseSlot>;
+}
+type AlertCloseProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, AlertCloseOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Alert: ComponentThemeConfig<AlertProps, AlertSlot>;
+        AlertContent: ComponentThemeConfig<AlertContentProps, AlertContentSlot>;
+        AlertTitle: ComponentThemeConfig<AlertTitleProps, AlertTitleSlot>;
+        AlertDescription: ComponentThemeConfig<AlertDescriptionProps, AlertDescriptionSlot>;
+        AlertActions: ComponentThemeConfig<AlertActionsProps, AlertActionsSlot>;
+        AlertClose: ComponentThemeConfig<AlertCloseProps, AlertCloseSlot>;
+    }
+}
+
+declare const Alert: {
+    <T extends react.ElementType = "div">(props: AlertProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    Content: {
+        <T extends react.ElementType = "div">(props: AlertContentProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        <T extends react.ElementType = "h5">(props: AlertTitleProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "p">(props: AlertDescriptionProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Actions: {
+        <T extends react.ElementType = "div">(props: AlertActionsProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Close: {
+        <T extends react.ElementType = "button">(props: AlertCloseProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+};
+
+type BadgeVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning' | 'verified' | 'purple' | 'cyan' | 'business' | 'teal' | 'white' | 'dark';
 type BadgeAppearance = 'filled' | 'filledLight' | 'outlined' | 'text';
 type BadgeSize = 'small' | 'base' | 'large';
 type BadgeSlot = 'root' | 'label' | 'icon';
@@ -298,7 +404,7 @@ interface BadgeProps extends Omit<TakeoffHTMLProps<'span'>, 'children'> {
      */
     rounded?: boolean;
     /**
-     * Renders a minimal colored dot (6×6px) with no content.
+     * Renders a minimal colored dot (8×8px) with no content.
      * When true, children, startContent, and endContent are ignored.
      * @defaultValue false
      */
@@ -327,8 +433,127 @@ declare module '../../core/theme' {
 }
 
 declare const Badge: {
-    (props: BadgeProps): react_jsx_runtime.JSX.Element;
+    (props: BadgeProps): react.JSX.Element;
+    displayName: string;
+};
+
+/**
+ * Density scale. `'base'` matches the default body line-height; `'large'`
+ * lifts the trail in hero or page-header contexts.
+ */
+type BreadcrumbSize = 'base' | 'large';
+/**
+ * Visual style. `'basic'` is the bare text trail; `'outlined'` renders each
+ * crumb as a bordered, backgrounded chip.
+ */
+type BreadcrumbType = 'basic' | 'outlined';
+
+type BreadcrumbNavigationHandler = NavigationHandler;
+type BreadcrumbPressEvent = PressEvent;
+type BreadcrumbSlot = 'root';
+type BreadcrumbListSlot = 'root';
+type BreadcrumbItemSlot = 'root';
+type BreadcrumbLinkSlot = 'root';
+type BreadcrumbPageSlot = 'root';
+type BreadcrumbSeparatorSlot = 'root';
+interface BreadcrumbOwnProps {
+    /**
+     * Density scale cascaded to every part through context.
+     * @defaultValue 'base'
+     */
+    size?: BreadcrumbSize;
+    /**
+     * Visual style cascaded to every part through context.
+     * @defaultValue 'basic'
+     */
+    type?: BreadcrumbType;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<BreadcrumbSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<BreadcrumbSlot>;
+}
+type BreadcrumbProps<T extends ElementType = 'nav'> = PolymorphicProps<'nav', T, BreadcrumbOwnProps & Pick<BreadcrumbProps$1, 'aria-label' | 'onNavigate' | 'disabled'>>;
+interface BreadcrumbListOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<BreadcrumbListSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<BreadcrumbListSlot>;
+}
+type BreadcrumbListProps<T extends ElementType = 'ol'> = PolymorphicProps<'ol', T, BreadcrumbListOwnProps>;
+interface BreadcrumbItemOwnProps {
+    /**
+     * Item content — typically a `Breadcrumb.Link` or `Breadcrumb.Page`, or a
+     * render function that receives `{ position, isCurrent, isDisabled }` so
+     * consumers can swap content without reading the item context manually.
+     */
+    children?: ReactNode | ((state: BreadcrumbItemRenderProps) => ReactNode);
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<BreadcrumbItemSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<BreadcrumbItemSlot>;
+}
+type BreadcrumbItemProps<T extends ElementType = 'li'> = PolymorphicProps<'li', T, BreadcrumbItemOwnProps>;
+interface BreadcrumbLinkOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<BreadcrumbLinkSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<BreadcrumbLinkSlot>;
+}
+type BreadcrumbLinkProps<T extends ElementType = 'a'> = PolymorphicProps<'a', T, BreadcrumbLinkOwnProps & Pick<BreadcrumbLinkProps$1, 'href' | 'disabled' | 'isExternal' | 'target' | 'rel' | 'onPress'>>;
+interface BreadcrumbPageOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<BreadcrumbPageSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<BreadcrumbPageSlot>;
+}
+type BreadcrumbPageProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, BreadcrumbPageOwnProps>;
+interface BreadcrumbSeparatorOwnProps {
+    /**
+     * Override the default chevron separator. Plain content renders inside the
+     * canonical `<li aria-hidden>` owner node.
+     */
+    children?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<BreadcrumbSeparatorSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<BreadcrumbSeparatorSlot>;
+}
+type BreadcrumbSeparatorProps<T extends ElementType = 'li'> = PolymorphicProps<'li', T, BreadcrumbSeparatorOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Breadcrumb: ComponentThemeConfig<BreadcrumbProps>;
+        BreadcrumbList: ComponentThemeConfig<BreadcrumbListProps>;
+        BreadcrumbItem: ComponentThemeConfig<BreadcrumbItemProps>;
+        BreadcrumbLink: ComponentThemeConfig<BreadcrumbLinkProps>;
+        BreadcrumbPage: ComponentThemeConfig<BreadcrumbPageProps>;
+        BreadcrumbSeparator: ComponentThemeConfig<BreadcrumbSeparatorProps>;
+    }
+}
+
+declare const Breadcrumb: {
+    <T extends react.ElementType = "nav">(props: BreadcrumbProps<T>): react.JSX.Element;
     displayName: string;
+} & {
+    List: {
+        <T extends react.ElementType = "ol">(props: BreadcrumbListProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        <T extends react.ElementType = "li">(props: BreadcrumbItemProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Link: {
+        <T extends react.ElementType = "a">(props: BreadcrumbLinkProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Page: {
+        <T extends react.ElementType = "span">(props: BreadcrumbPageProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Separator: {
+        <T extends react.ElementType = "li">(props: BreadcrumbSeparatorProps<T>): react.JSX.Element;
+        displayName: string;
+    };
 };
 
 type ButtonVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning' | 'white' | 'black';
@@ -368,6 +593,10 @@ interface ButtonOwnProps {
      * Content rendered after children. Same shape as `startContent`.
      */
     endContent?: ReactNode;
+    /** Whether the button shows a loading spinner. */
+    loading?: boolean;
+    /** Whether the button is pressed. When defined, creates a toggle button. */
+    pressed?: boolean;
     /** Per-slot extra classes. */
     classNames?: ClassNamesMap<ButtonSlot>;
     /** Per-slot HTML-attribute overrides. */
@@ -378,7 +607,7 @@ interface ButtonOwnProps {
  * link-styled buttons) — `as`, ref, and the native attributes of the rendered
  * element are inherited from Spar's `PolymorphicProps`.
  */
-type ButtonProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, ButtonOwnProps & Pick<ButtonProps$1, 'isPressed' | 'onPressedChange' | 'isLoading'>>;
+type ButtonProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, ButtonOwnProps & Pick<ButtonProps$1, 'onPressedChange'>>;
 declare module '../../core/theme' {
     interface ComponentThemeRegistry {
         Button: ComponentThemeConfig<ButtonProps, ButtonSlot>;
@@ -386,12 +615,113 @@ declare module '../../core/theme' {
 }
 
 declare const Button: {
-    <T extends ElementType = "button">(props: ButtonProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends ElementType = "button">(props: ButtonProps<T>): react.JSX.Element;
+    displayName: string;
+};
+
+type CardHeaderType = 'basic' | 'divided' | 'light' | 'dark' | 'primary';
+type CardFooterType = 'basic' | 'divided' | 'light';
+type CardSlot = 'root';
+type CardHeaderSlot = 'root';
+type CardTitleSlot = 'root';
+type CardDescriptionSlot = 'root';
+type CardBodySlot = 'root';
+type CardFooterSlot = 'root';
+interface CardOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<CardSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<CardSlot>;
+}
+type CardProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, CardOwnProps>;
+interface CardHeaderOwnProps {
+    /**
+     * Type of the header.
+     * @defaultValue 'basic'
+     */
+    headerType?: CardHeaderType;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<CardHeaderSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<CardHeaderSlot>;
+}
+type CardHeaderProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, CardHeaderOwnProps>;
+interface CardTitleOwnProps {
+    /**
+     * Semantic heading level used when `as` is not provided.
+     * @defaultValue 5
+     */
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<CardTitleSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<CardTitleSlot>;
+}
+type CardTitleProps<T extends ElementType = 'h5'> = PolymorphicProps<'h5', T, CardTitleOwnProps>;
+interface CardDescriptionOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<CardDescriptionSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<CardDescriptionSlot>;
+}
+type CardDescriptionProps<T extends ElementType = 'p'> = PolymorphicProps<'p', T, CardDescriptionOwnProps>;
+interface CardBodyOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<CardBodySlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<CardBodySlot>;
+}
+type CardBodyProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, CardBodyOwnProps>;
+interface CardFooterOwnProps {
+    /**
+     * Type of the footer.
+     * @defaultValue 'basic'
+     */
+    footerType?: CardFooterType;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<CardFooterSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<CardFooterSlot>;
+}
+type CardFooterProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, CardFooterOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Card: ComponentThemeConfig<CardProps, CardSlot>;
+        CardHeader: ComponentThemeConfig<CardHeaderProps, CardHeaderSlot>;
+        CardTitle: ComponentThemeConfig<CardTitleProps, CardTitleSlot>;
+        CardDescription: ComponentThemeConfig<CardDescriptionProps, CardDescriptionSlot>;
+        CardBody: ComponentThemeConfig<CardBodyProps, CardBodySlot>;
+        CardFooter: ComponentThemeConfig<CardFooterProps, CardFooterSlot>;
+    }
+}
+
+declare const Card: {
+    <T extends react.ElementType = "div">(props: CardProps<T>): react.JSX.Element;
     displayName: string;
+} & {
+    Header: {
+        <T extends react.ElementType = "div">(props: CardHeaderProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        <T extends react.ElementType = "h5">(props: CardTitleProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "p">(props: CardDescriptionProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        <T extends react.ElementType = "div">(props: CardBodyProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        <T extends react.ElementType = "div">(props: CardFooterProps<T>): react.JSX.Element;
+        displayName: string;
+    };
 };
 
 type CheckboxSize = 'small' | 'base';
-type CheckboxType = 'default' | 'card';
 type CheckboxSlot = 'root' | 'indicator' | 'icon';
 /**
  * Render props passed to the root `Checkbox` render-prop child. Re-exports
@@ -447,12 +777,6 @@ interface CheckboxOwnProps {
      * @defaultValue 'base'
      */
     size?: CheckboxSize;
-    /**
-     * Visual appearance. `'card'` mirrors Takeoff Core's bordered card variant
-     * for opt-in card-style selection rows.
-     * @defaultValue 'default'
-     */
-    type?: CheckboxType;
     /** Per-slot extra classes. */
     classNames?: ClassNamesMap<CheckboxSlot>;
     /** Per-slot HTML-attribute overrides. */
@@ -489,15 +813,85 @@ declare module '../../core/theme' {
 }
 
 declare const Checkbox: {
-    <T extends react.ElementType = "span">(props: CheckboxProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends react.ElementType = "span">(props: CheckboxProps<T>): react.JSX.Element;
     displayName: string;
 } & {
     Indicator: {
-        (props: CheckboxIndicatorProps): react_jsx_runtime.JSX.Element;
+        (props: CheckboxIndicatorProps): react.JSX.Element;
         displayName: string;
     };
 };
 
+type ChipVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning' | 'verified' | 'purple' | 'cyan' | 'business' | 'teal' | 'white' | 'dark';
+type ChipAppearance = 'filled' | 'filledLight' | 'outlined';
+type ChipSize = 'small' | 'base' | 'large';
+type ChipSlot = 'root' | 'label' | 'remove';
+interface ChipProps extends Omit<TakeoffHTMLProps<'span'>, 'children'> {
+    /**
+     * Color variant.
+     * @defaultValue 'primary'
+     */
+    variant?: ChipVariant;
+    /**
+     * Visual appearance.
+     * @defaultValue 'filled'
+     */
+    appearance?: ChipAppearance;
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: ChipSize;
+    /**
+     * Disables interactive affordances and remove actions.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Renders a remove button that dismisses the chip from the DOM when pressed.
+     * @defaultValue false
+     */
+    removable?: boolean;
+    /**
+     * Makes the chip root keyboard-focusable and button-like for click actions.
+     * @defaultValue false
+     */
+    clickable?: boolean;
+    /**
+     * Whether the chip removes itself from the DOM after a remove action.
+     *
+     * Removal is tracked in internal state, so set `autoDismiss={false}` when the
+     * parent owns the chip list (e.g. renders chips from an array) and let
+     * `onRemove` drive the parent's state — otherwise the chip and the parent's
+     * list become two sources of truth.
+     * @defaultValue true
+     */
+    autoDismiss?: boolean;
+    /**
+     * Called when the remove button is pressed or a focused clickable chip
+     * receives Backspace/Delete.
+     */
+    onRemove?: () => void;
+    /** Chip content. */
+    children?: ReactNode;
+    /** Ref forwarded to the root span element. */
+    ref?: Ref<HTMLSpanElement>;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<ChipSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<ChipSlot>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Chip: ComponentThemeConfig<ChipProps, ChipSlot>;
+    }
+}
+
+declare const Chip: {
+    (props: ChipProps): react.JSX.Element | null;
+    displayName: string;
+};
+
 /**
  * Side from which the drawer slides in.
  * @defaultValue 'right'
@@ -510,7 +904,7 @@ type DrawerTitleSlot = 'root';
 type DrawerDescriptionSlot = 'root';
 type DrawerBodySlot = 'root';
 type DrawerFooterSlot = 'root';
-type DrawerCloseButtonSlot = 'root';
+type DrawerCloseSlot = 'root';
 /**
  * Public props for the Drawer root. Wraps Spar's Dialog in modal mode to
  * create a slide-in side panel. State-only — renders no DOM, so no
@@ -518,28 +912,30 @@ type DrawerCloseButtonSlot = 'root';
  * `slotProps` (state-driven styling lives on the Panel/Overlay/Header
  * children, which read shared values from context).
  */
-interface DrawerProps extends Pick<DialogProps, 'id' | 'open' | 'defaultOpen' | 'onOpenChange' | 'disabled'> {
+interface DrawerProps extends Pick<DialogProps$1, 'id' | 'open' | 'defaultOpen' | 'onOpenChange' | 'disabled'> {
     /** Side the drawer slides in from. */
     placement?: DrawerPlacement;
     /** Whether the drawer can be dismissed by clicking outside or pressing Escape. @defaultValue true */
-    dismissable?: boolean;
+    dismissible?: boolean;
     children?: ReactNode;
 }
 interface DrawerTriggerOwnProps {
     classNames?: ClassNamesMap<'root'>;
     slotProps?: SlotPropsMap<'root'>;
 }
-type DrawerTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DrawerTriggerOwnProps & Pick<DialogTriggerProps, 'children'>>;
+type DrawerTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DrawerTriggerOwnProps & Pick<DialogTriggerProps$1, 'children'>>;
 type DrawerOverlayIntensity = 'lightest' | 'light' | 'base' | 'dark' | 'darkest';
 interface DrawerOverlayOwnProps {
     /** When true, the overlay is rendered but visually invisible. @defaultValue false */
     invisible?: boolean;
     /** Overlay backdrop intensity. @defaultValue 'base' */
     intensity?: DrawerOverlayIntensity;
+    /** Applies backdrop blur on the overlay. @defaultValue false */
+    blur?: boolean;
     classNames?: ClassNamesMap<DrawerOverlaySlot>;
     slotProps?: SlotPropsMap<DrawerOverlaySlot>;
 }
-type DrawerOverlayProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerOverlayOwnProps & Pick<DialogOverlayProps, 'container'>>;
+type DrawerOverlayProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerOverlayOwnProps & Pick<DialogOverlayProps$1, 'container'>>;
 interface DrawerPanelOwnProps {
     classNames?: ClassNamesMap<DrawerPanelSlot>;
     slotProps?: SlotPropsMap<DrawerPanelSlot>;
@@ -557,7 +953,7 @@ interface DrawerTitleOwnProps {
     classNames?: ClassNamesMap<DrawerTitleSlot>;
     slotProps?: SlotPropsMap<DrawerTitleSlot>;
 }
-type DrawerTitleProps<T extends ElementType = 'h2'> = PolymorphicProps<'h2', T, DrawerTitleOwnProps & Pick<DialogTitleProps, 'level'>>;
+type DrawerTitleProps<T extends ElementType = 'h5'> = PolymorphicProps<'h5', T, DrawerTitleOwnProps & Pick<DialogTitleProps$1, 'level'>>;
 interface DrawerDescriptionOwnProps {
     classNames?: ClassNamesMap<DrawerDescriptionSlot>;
     slotProps?: SlotPropsMap<DrawerDescriptionSlot>;
@@ -576,11 +972,11 @@ interface DrawerFooterOwnProps {
     slotProps?: SlotPropsMap<DrawerFooterSlot>;
 }
 type DrawerFooterProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerFooterOwnProps>;
-interface DrawerCloseButtonOwnProps {
-    classNames?: ClassNamesMap<DrawerCloseButtonSlot>;
-    slotProps?: SlotPropsMap<DrawerCloseButtonSlot>;
+interface DrawerCloseOwnProps {
+    classNames?: ClassNamesMap<DrawerCloseSlot>;
+    slotProps?: SlotPropsMap<DrawerCloseSlot>;
 }
-type DrawerCloseButtonProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DrawerCloseButtonOwnProps & Pick<DialogCloseProps, 'children'>>;
+type DrawerCloseProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DrawerCloseOwnProps & Pick<DialogCloseProps$1, 'children'>>;
 declare module '../../core/theme' {
     interface ComponentThemeRegistry {
         Drawer: StateOnlyComponentThemeConfig<DrawerProps>;
@@ -592,116 +988,454 @@ declare module '../../core/theme' {
         DrawerDescription: ComponentThemeConfig<DrawerDescriptionProps>;
         DrawerBody: ComponentThemeConfig<DrawerBodyProps>;
         DrawerFooter: ComponentThemeConfig<DrawerFooterProps>;
-        DrawerCloseButton: ComponentThemeConfig<DrawerCloseButtonProps>;
+        DrawerClose: ComponentThemeConfig<DrawerCloseProps>;
     }
 }
 
 declare const Drawer: {
-    (props: DrawerProps): react_jsx_runtime.JSX.Element;
+    (props: DrawerProps): react.JSX.Element;
     displayName: string;
 } & {
     Trigger: {
-        <T extends react.ElementType = "button">(props: DrawerTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "button">(props: DrawerTriggerProps<T>): react.JSX.Element;
         displayName: string;
     };
     Overlay: {
-        <T extends react.ElementType = "div">(props: DrawerOverlayProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: DrawerOverlayProps<T>): react.JSX.Element;
         displayName: string;
     };
     Panel: {
-        <T extends react.ElementType = "div">(props: DrawerPanelProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: DrawerPanelProps<T>): react.JSX.Element;
         displayName: string;
     };
     Header: {
-        <T extends react.ElementType = "div">(props: DrawerHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: DrawerHeaderProps<T>): react.JSX.Element;
         displayName: string;
     };
     Title: {
-        <T extends react.ElementType = "h2">(props: DrawerTitleProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "h5">(props: DrawerTitleProps<T>): react.JSX.Element;
         displayName: string;
     };
     Description: {
-        <T extends react.ElementType = "p">(props: DrawerDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "p">(props: DrawerDescriptionProps<T>): react.JSX.Element;
         displayName: string;
     };
     Body: {
-        <T extends react.ElementType = "div">(props: DrawerBodyProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: DrawerBodyProps<T>): react.JSX.Element;
         displayName: string;
     };
     Footer: {
-        <T extends react.ElementType = "div">(props: DrawerFooterProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: DrawerFooterProps<T>): react.JSX.Element;
         displayName: string;
     };
-    CloseButton: {
-        <T extends react.ElementType = "button">(props: DrawerCloseButtonProps<T>): react_jsx_runtime.JSX.Element;
+    Close: {
+        <T extends react.ElementType = "button">(props: DrawerCloseProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
-type FieldSlot = 'root';
-type FieldLabelSlot = 'root' | 'asterisk';
-type FieldDescriptionSlot = 'root';
-type FieldErrorMessageSlot = 'root';
-interface FieldOwnProps {
-    classNames?: ClassNamesMap<FieldSlot>;
-    slotProps?: SlotPropsMap<FieldSlot>;
-}
+type DialogTriggerSlot = 'root';
+type DialogOverlaySlot = 'root';
+type DialogPanelSlot = 'root';
+type DialogHeaderSlot = 'root';
+type DialogTitleSlot = 'root';
+type DialogDescriptionSlot = 'root';
+type DialogBodySlot = 'root';
+type DialogFooterSlot = 'root';
+type DialogCloseSlot = 'root';
+type DialogOverlayIntensity = 'lightest' | 'light' | 'base' | 'dark' | 'darkest';
+type DialogHeaderType = 'basic' | 'divided' | 'light' | 'dark' | 'primary';
+type DialogFooterType = 'basic' | 'divided' | 'light';
 /**
- * Public props for the Field root. Provides shared ARIA context for nested
- * form controls (Input, Switch, Checkbox, etc.) plus styled label, helper
- * text, and error message slots.
+ * Public props for the Dialog root. State-only — renders no DOM, so no
+ * polymorphic `as` and no native HTML props.
  */
-type FieldProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, FieldOwnProps & Pick<FieldProps$1, 'id' | 'invalid' | 'disabled' | 'required' | 'readOnly' | 'children'>>;
-interface FieldLabelOwnProps {
-    classNames?: ClassNamesMap<FieldLabelSlot>;
-    slotProps?: SlotPropsMap<FieldLabelSlot>;
+interface DialogProps extends Pick<DialogProps$1, 'id' | 'open' | 'defaultOpen' | 'onOpenChange' | 'modal' | 'disabled' | 'forceMount' | 'children'> {
+    /** Whether the dialog can be dismissed by clicking outside or pressing Escape. @defaultValue true */
+    dismissible?: boolean;
 }
-type FieldLabelProps<T extends ElementType = 'label'> = PolymorphicProps<'label', T, FieldLabelOwnProps & Pick<FieldLabelProps$1, 'children'>>;
-interface FieldDescriptionOwnProps {
-    classNames?: ClassNamesMap<FieldDescriptionSlot>;
-    slotProps?: SlotPropsMap<FieldDescriptionSlot>;
+interface DialogTriggerOwnProps {
+    classNames?: ClassNamesMap<DialogTriggerSlot>;
+    slotProps?: SlotPropsMap<DialogTriggerSlot>;
 }
-type FieldDescriptionProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, FieldDescriptionOwnProps & Pick<FieldDescriptionProps$1, 'children'>>;
-interface FieldErrorMessageOwnProps {
-    classNames?: ClassNamesMap<FieldErrorMessageSlot>;
-    slotProps?: SlotPropsMap<FieldErrorMessageSlot>;
+type DialogTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DialogTriggerOwnProps & Pick<DialogTriggerProps$1, 'children'>>;
+interface DialogOverlayOwnProps {
+    /** When true, the overlay is rendered but visually invisible. @defaultValue false */
+    invisible?: boolean;
+    /** Overlay backdrop intensity. @defaultValue 'base' */
+    intensity?: DialogOverlayIntensity;
+    /** Applies backdrop blur on the overlay. @defaultValue false */
+    blur?: boolean;
+    classNames?: ClassNamesMap<DialogOverlaySlot>;
+    slotProps?: SlotPropsMap<DialogOverlaySlot>;
+}
+type DialogOverlayProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DialogOverlayOwnProps & Pick<DialogOverlayProps$1, 'container'>>;
+interface DialogPanelOwnProps {
+    classNames?: ClassNamesMap<DialogPanelSlot>;
+    slotProps?: SlotPropsMap<DialogPanelSlot>;
+}
+type DialogPanelProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DialogPanelOwnProps & Pick<DialogContentProps, 'role' | 'container' | 'trapFocus' | 'restoreFocus' | 'initialFocus' | 'finalFocus' | 'onOpenAutoFocus' | 'onCloseAutoFocus' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onInteractOutside'>>;
+interface DialogTitleOwnProps {
+    classNames?: ClassNamesMap<DialogTitleSlot>;
+    slotProps?: SlotPropsMap<DialogTitleSlot>;
+}
+interface DialogHeaderOwnProps {
+    /** Type of the header. @defaultValue 'basic' */
+    headerType?: DialogHeaderType;
+    classNames?: ClassNamesMap<DialogHeaderSlot>;
+    slotProps?: SlotPropsMap<DialogHeaderSlot>;
+}
+type DialogHeaderProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DialogHeaderOwnProps>;
+type DialogTitleProps<T extends ElementType = 'h5'> = PolymorphicProps<'h5', T, DialogTitleOwnProps & Pick<DialogTitleProps$1, 'level'>>;
+interface DialogDescriptionOwnProps {
+    classNames?: ClassNamesMap<DialogDescriptionSlot>;
+    slotProps?: SlotPropsMap<DialogDescriptionSlot>;
+}
+type DialogDescriptionProps<T extends ElementType = 'p'> = PolymorphicProps<'p', T, DialogDescriptionOwnProps>;
+interface DialogBodyOwnProps {
+    classNames?: ClassNamesMap<DialogBodySlot>;
+    slotProps?: SlotPropsMap<DialogBodySlot>;
+}
+type DialogBodyProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DialogBodyOwnProps>;
+interface DialogFooterOwnProps {
+    /** Type of the footer. @defaultValue 'basic' */
+    footerType?: DialogFooterType;
+    classNames?: ClassNamesMap<DialogFooterSlot>;
+    slotProps?: SlotPropsMap<DialogFooterSlot>;
 }
-type FieldErrorMessageProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, FieldErrorMessageOwnProps & Pick<FieldErrorMessageProps$1, 'children'>>;
+type DialogFooterProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DialogFooterOwnProps>;
+interface DialogCloseOwnProps {
+    classNames?: ClassNamesMap<DialogCloseSlot>;
+    slotProps?: SlotPropsMap<DialogCloseSlot>;
+}
+type DialogCloseProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DialogCloseOwnProps & Pick<DialogCloseProps$1, 'children'>>;
 declare module '../../core/theme' {
     interface ComponentThemeRegistry {
-        Field: ComponentThemeConfig<FieldProps, FieldSlot>;
-        FieldLabel: ComponentThemeConfig<FieldLabelProps, FieldLabelSlot>;
-        FieldDescription: ComponentThemeConfig<FieldDescriptionProps, FieldDescriptionSlot>;
-        FieldErrorMessage: ComponentThemeConfig<FieldErrorMessageProps, FieldErrorMessageSlot>;
+        Dialog: StateOnlyComponentThemeConfig<DialogProps>;
+        DialogTrigger: ComponentThemeConfig<DialogTriggerProps, DialogTriggerSlot>;
+        DialogOverlay: ComponentThemeConfig<DialogOverlayProps, DialogOverlaySlot>;
+        DialogPanel: ComponentThemeConfig<DialogPanelProps, DialogPanelSlot>;
+        DialogHeader: ComponentThemeConfig<DialogHeaderProps, DialogHeaderSlot>;
+        DialogTitle: ComponentThemeConfig<DialogTitleProps, DialogTitleSlot>;
+        DialogDescription: ComponentThemeConfig<DialogDescriptionProps, DialogDescriptionSlot>;
+        DialogBody: ComponentThemeConfig<DialogBodyProps, DialogBodySlot>;
+        DialogFooter: ComponentThemeConfig<DialogFooterProps, DialogFooterSlot>;
+        DialogClose: ComponentThemeConfig<DialogCloseProps, DialogCloseSlot>;
     }
 }
 
-declare const Field: {
-    <T extends react.ElementType = "div">(props: FieldProps<T>): react_jsx_runtime.JSX.Element;
+declare const Dialog: {
+    (props: DialogProps): react.JSX.Element;
     displayName: string;
 } & {
-    Label: {
-        <T extends react.ElementType = "label">(props: FieldLabelProps<T>): react_jsx_runtime.JSX.Element;
+    Trigger: {
+        <T extends react.ElementType = "button">(props: DialogTriggerProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Overlay: {
+        <T extends react.ElementType = "div">(props: DialogOverlayProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Panel: {
+        <T extends react.ElementType = "div">(props: DialogPanelProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        <T extends react.ElementType = "div">(props: DialogHeaderProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        <T extends react.ElementType = "h5">(props: DialogTitleProps<T>): react.JSX.Element;
         displayName: string;
     };
     Description: {
-        <T extends react.ElementType = "div">(props: FieldDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "p">(props: DialogDescriptionProps<T>): react.JSX.Element;
         displayName: string;
     };
-    ErrorMessage: {
-        <T extends react.ElementType = "div">(props: FieldErrorMessageProps<T>): react_jsx_runtime.JSX.Element;
+    Body: {
+        <T extends react.ElementType = "div">(props: DialogBodyProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        <T extends react.ElementType = "div">(props: DialogFooterProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Close: {
+        <T extends react.ElementType = "button">(props: DialogCloseProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
-type InputSize = 'small' | 'base' | 'large';
-type InputSlot = 'root';
-type InputContainerSlot = 'root' | 'startContent' | 'endContent';
-type InputFieldSlot = 'root';
-type InputPrefixSlot = 'root';
-type InputSuffixSlot = 'root';
-/**
- * Visual + slot props owned by takeoff-v2 for the Input root. The `size`
+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';
+type FieldErrorMessageSlot = 'root' | 'icon';
+interface FieldOwnProps {
+    classNames?: ClassNamesMap<FieldSlot>;
+    slotProps?: SlotPropsMap<FieldSlot>;
+}
+/**
+ * Public props for the Field root. Provides shared ARIA context for nested
+ * form controls (Input, Switch, Checkbox, etc.) plus styled label, helper
+ * text, and error message slots.
+ */
+type FieldProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, FieldOwnProps & Pick<FieldProps$1, 'id' | 'invalid' | 'disabled' | 'required' | 'optional' | 'readOnly' | 'children'>>;
+interface FieldLabelOwnProps {
+    classNames?: ClassNamesMap<FieldLabelSlot>;
+    slotProps?: SlotPropsMap<FieldLabelSlot>;
+}
+type FieldLabelProps<T extends ElementType = 'label'> = PolymorphicProps<'label', T, FieldLabelOwnProps & Pick<FieldLabelProps$1, 'children'>>;
+interface FieldDescriptionOwnProps {
+    classNames?: ClassNamesMap<FieldDescriptionSlot>;
+    slotProps?: SlotPropsMap<FieldDescriptionSlot>;
+}
+type FieldDescriptionProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, FieldDescriptionOwnProps & Pick<FieldDescriptionProps$1, 'children'>>;
+interface FieldErrorMessageOwnProps {
+    classNames?: ClassNamesMap<FieldErrorMessageSlot>;
+    slotProps?: SlotPropsMap<FieldErrorMessageSlot>;
+}
+type FieldErrorMessageProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, FieldErrorMessageOwnProps & Pick<FieldErrorMessageProps$1, 'children'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Field: ComponentThemeConfig<FieldProps, FieldSlot>;
+        FieldLabel: ComponentThemeConfig<FieldLabelProps, FieldLabelSlot>;
+        FieldDescription: ComponentThemeConfig<FieldDescriptionProps, FieldDescriptionSlot>;
+        FieldErrorMessage: ComponentThemeConfig<FieldErrorMessageProps, FieldErrorMessageSlot>;
+    }
+}
+
+declare const Field: {
+    <T extends react.ElementType = "div">(props: FieldProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    Label: {
+        <T extends react.ElementType = "label">(props: FieldLabelProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "div">(props: FieldDescriptionProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    ErrorMessage: {
+        <T extends react.ElementType = "div">(props: FieldErrorMessageProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+};
+
+type InputSize = 'small' | 'base' | 'large';
+type InputSlot = 'root';
+type InputFieldSlot = 'root';
+type InputPrefixSlot = 'root';
+type InputSuffixSlot = 'root';
+type InputLeadingIconSlot = 'root';
+type InputTrailingIconSlot = 'root';
+type InputClearButtonSlot = 'root';
+type InputSpinnerSlot = 'root';
+type InputRevealButtonSlot = 'root';
+type InputStrengthSlot = 'root';
+type InputStepperSlot = 'root';
+type InputDecrementSlot = 'root';
+type InputIncrementSlot = 'root';
+type InputChipsSlot = 'root';
+/**
+ * Visual + slot props owned by takeoff-v2 for the Input root. The `size`
  * cascades to descendants through a visual context so InputField renders at
  * the same scale without consumers having to repeat the prop.
  */
@@ -729,31 +1463,6 @@ interface InputFieldOwnProps {
     slotProps?: SlotPropsMap<InputFieldSlot>;
 }
 type InputFieldProps<T extends ElementType = 'input'> = PolymorphicProps<'input', T, InputFieldOwnProps & Pick<InputFieldProps$1, 'autoFocus'>>;
-/**
- * Visual row wrapping the field plus optional prefix, suffix, leading/trailing
- * icons. Mirrors the SCSS `.tk-input-container` and is where state attributes
- * (`data-invalid`, `data-disabled`, `data-readonly`) land for styling the
- * bordered input row.
- */
-interface InputContainerOwnProps {
-    /**
-     * Content rendered before the field — typically an icon, but accepts any
-     * node (chip, button, etc.). Rendered inside the `startContent` slot
-     * (`.tk-input-start-content`).
-     */
-    startContent?: ReactNode;
-    /**
-     * Content rendered after the field. Same shape as `startContent`, rendered
-     * inside the `endContent` slot (`.tk-input-end-content`).
-     */
-    endContent?: ReactNode;
-    /** Per-slot class name overrides. */
-    classNames?: ClassNamesMap<InputContainerSlot>;
-    /** Per-slot HTML attribute overrides. */
-    slotProps?: SlotPropsMap<InputContainerSlot>;
-    children?: ReactNode;
-}
-type InputContainerProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, InputContainerOwnProps>;
 interface InputPrefixOwnProps {
     /** Per-slot class name overrides. */
     classNames?: ClassNamesMap<InputPrefixSlot>;
@@ -770,40 +1479,212 @@ interface InputSuffixOwnProps {
     children?: ReactNode;
 }
 type InputSuffixProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, InputSuffixOwnProps>;
+interface InputLeadingIconOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputLeadingIconSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputLeadingIconSlot>;
+    children?: ReactNode;
+}
+type InputLeadingIconProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, InputLeadingIconOwnProps>;
+interface InputTrailingIconOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputTrailingIconSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputTrailingIconSlot>;
+    children?: ReactNode;
+}
+type InputTrailingIconProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, InputTrailingIconOwnProps>;
+interface InputClearButtonOwnProps {
+    /** Called after the field value is cleared. */
+    onClear?: () => void;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputClearButtonSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputClearButtonSlot>;
+    children?: ReactNode;
+}
+type InputClearButtonProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, InputClearButtonOwnProps>;
+interface InputSpinnerOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputSpinnerSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputSpinnerSlot>;
+    children?: ReactNode;
+}
+type InputSpinnerProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, InputSpinnerOwnProps>;
+interface InputRevealButtonOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputRevealButtonSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputRevealButtonSlot>;
+    children?: ReactNode;
+}
+type InputRevealButtonProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, InputRevealButtonOwnProps>;
+interface InputStrengthOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputStrengthSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputStrengthSlot>;
+    children?: ReactNode;
+}
+/**
+ * Password strength meter rendered below the bordered row. It derives its
+ * level from the field value cascaded through the Input context, so it must be
+ * placed inside `Input` (it is hoisted out of the bordered row at render time).
+ */
+type InputStrengthProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, InputStrengthOwnProps>;
+interface InputStepperOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputStepperSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputStepperSlot>;
+    children?: ReactNode;
+}
+type InputStepperProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, InputStepperOwnProps>;
+interface InputDecrementOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputDecrementSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputDecrementSlot>;
+    children?: ReactNode;
+}
+type InputDecrementProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, InputDecrementOwnProps>;
+interface InputIncrementOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputIncrementSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputIncrementSlot>;
+    children?: ReactNode;
+}
+type InputIncrementProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, InputIncrementOwnProps>;
+interface InputChipsOwnProps {
+    /**
+     * Committed tags (controlled). Pair with `onValueChange`. Spar's Input is a
+     * scalar primitive with no array model, so the chips value is owned here as a
+     * react-enhancement rather than picked from Spar.
+     */
+    value?: string[];
+    /** Initial tags for uncontrolled usage. */
+    defaultValue?: string[];
+    /** Called with the next tag array after a commit or removal. */
+    onValueChange?: (value: string[]) => void;
+    /** Optional character that commits the field text as a tag (Enter always commits). */
+    separator?: string;
+    /** Maximum number of tags. Further commits are ignored once reached. */
+    max?: number;
+    /** Allow committing a tag that already exists. @defaultValue false */
+    allowDuplicates?: boolean;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputChipsSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputChipsSlot>;
+    children?: ReactNode;
+}
+/**
+ * Chips region rendered next to `Input.Field`. Owns the tag array, renders each
+ * committed tag via the shared `Chip` token, and attaches its key handling
+ * (Enter to commit, Backspace to remove the last tag) to the shared field ref
+ * so `Input.Field` stays generic.
+ */
+type InputChipsProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, InputChipsOwnProps>;
 declare module '../../core/theme' {
     interface ComponentThemeRegistry {
         Input: ComponentThemeConfig<InputProps, InputSlot>;
-        InputContainer: ComponentThemeConfig<InputContainerProps, InputContainerSlot>;
         InputField: ComponentThemeConfig<InputFieldProps, InputFieldSlot>;
         InputPrefix: ComponentThemeConfig<InputPrefixProps, InputPrefixSlot>;
         InputSuffix: ComponentThemeConfig<InputSuffixProps, InputSuffixSlot>;
+        InputLeadingIcon: ComponentThemeConfig<InputLeadingIconProps, InputLeadingIconSlot>;
+        InputTrailingIcon: ComponentThemeConfig<InputTrailingIconProps, InputTrailingIconSlot>;
+        InputClearButton: ComponentThemeConfig<InputClearButtonProps, InputClearButtonSlot>;
+        InputSpinner: ComponentThemeConfig<InputSpinnerProps, InputSpinnerSlot>;
+        InputRevealButton: ComponentThemeConfig<InputRevealButtonProps, InputRevealButtonSlot>;
+        InputStrength: ComponentThemeConfig<InputStrengthProps, InputStrengthSlot>;
+        InputStepper: ComponentThemeConfig<InputStepperProps, InputStepperSlot>;
+        InputDecrement: ComponentThemeConfig<InputDecrementProps, InputDecrementSlot>;
+        InputIncrement: ComponentThemeConfig<InputIncrementProps, InputIncrementSlot>;
+        InputChips: ComponentThemeConfig<InputChipsProps, InputChipsSlot>;
     }
 }
 
 declare const Input: {
-    <T extends react.ElementType = "div">(props: InputProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends react.ElementType = "div">(props: InputProps<T>): react.JSX.Element;
     displayName: string;
 } & {
-    Container: {
-        <T extends react.ElementType = "div">(props: InputContainerProps<T>): react_jsx_runtime.JSX.Element;
-        displayName: string;
-    };
     Field: {
-        <T extends react.ElementType = "input">(props: InputFieldProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "input">(props: InputFieldProps<T>): react.JSX.Element;
         displayName: string;
     };
     Prefix: {
-        <T extends react.ElementType = "span">(props: InputPrefixProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "span">(props: InputPrefixProps<T>): react.JSX.Element;
         displayName: string;
     };
     Suffix: {
-        <T extends react.ElementType = "span">(props: InputSuffixProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "span">(props: InputSuffixProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    LeadingIcon: {
+        <T extends react.ElementType = "span">(props: InputLeadingIconProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    TrailingIcon: {
+        <T extends react.ElementType = "span">(props: InputTrailingIconProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    ClearButton: {
+        <T extends react.ElementType = "button">(props: InputClearButtonProps<T>): react.JSX.Element | null;
+        displayName: string;
+    };
+    Spinner: {
+        <T extends react.ElementType = "span">(props: InputSpinnerProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    RevealButton: {
+        <T extends react.ElementType = "button">(props: InputRevealButtonProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Strength: {
+        <T extends react.ElementType = "div">(props: InputStrengthProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Stepper: {
+        <T extends react.ElementType = "div">(props: InputStepperProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Decrement: {
+        <T extends react.ElementType = "button">(props: InputDecrementProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Increment: {
+        <T extends react.ElementType = "button">(props: InputIncrementProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Chips: {
+        <T extends react.ElementType = "div">(props: InputChipsProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
+type LabelSlot = 'root';
+interface LabelOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<LabelSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<LabelSlot>;
+}
+type LabelProps<T extends ElementType = 'label'> = PolymorphicProps<'label', T, LabelOwnProps & Pick<LabelProps$1, 'children' | 'required' | 'optional' | 'disabled' | 'readOnly' | 'invalid'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Label: ComponentThemeConfig<LabelProps, LabelSlot>;
+    }
+}
+
+declare const Label: {
+    <T extends ElementType = "label">(props: LabelProps<T>): react.JSX.Element;
+    displayName: string;
+};
+
 type RadioSize = 'small' | 'base' | 'large';
-type RadioType = 'default' | 'card';
 type RadioPosition = 'left' | 'right';
 type RadioSlot = 'root';
 type RadioItemSlot = 'root';
@@ -824,11 +1705,6 @@ interface RadioOwnProps {
      * @defaultValue 'base'
      */
     size?: RadioSize;
-    /**
-     * Visual variant. Cascades to descendant `Radio.Item`s via context.
-     * @defaultValue 'default'
-     */
-    type?: RadioType;
     /**
      * Marks the group as visually invalid. Cascades to descendant `Radio.Item`s.
      * When nested inside a `<Field>` with `invalid`, this is inherited
@@ -903,28 +1779,28 @@ declare module '../../core/theme' {
 }
 
 declare const Radio: {
-    <T extends react.ElementType = "div">(props: RadioProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends react.ElementType = "div">(props: RadioProps<T>): react.JSX.Element;
     displayName: string;
 } & {
     Item: {
-        <T extends react.ElementType = "label">(props: RadioItemProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "label">(props: RadioItemProps<T>): react.JSX.Element;
         displayName: string;
     };
     Indicator: {
-        <T extends react.ElementType = "span">(props: RadioIndicatorProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "span">(props: RadioIndicatorProps<T>): react.JSX.Element;
         displayName: string;
     };
     Label: {
-        <T extends react.ElementType = "span">(props: RadioLabelProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "span">(props: RadioLabelProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
 /**
  * Visual variant of the popover content.
- * @defaultValue 'dark'
+ * @defaultValue 'white'
  */
-type PopoverVariant = 'dark' | 'white' | 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+type PopoverVariant = 'white' | 'dark' | 'info' | 'success' | 'warning' | 'danger' | 'neutral';
 type PopoverTriggerSlot = 'root';
 type PopoverContentSlot = 'root';
 type PopoverHeaderSlot = 'root';
@@ -946,7 +1822,7 @@ type PopoverTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'b
 interface PopoverContentOwnProps {
     /**
      * Color variant.
-     * @defaultValue 'dark'
+     * @defaultValue 'white'
      */
     variant?: PopoverVariant;
     /** Per-slot extra classes. */
@@ -996,52 +1872,223 @@ declare module '../../core/theme' {
 }
 
 declare const Popover: {
-    (props: PopoverProps): react_jsx_runtime.JSX.Element;
+    (props: PopoverProps): react.JSX.Element;
     displayName: string;
 } & {
     Trigger: {
-        <T extends react.ElementType = "button">(props: PopoverTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "button">(props: PopoverTriggerProps<T>): react.JSX.Element;
         displayName: string;
     };
     Content: {
-        <T extends react.ElementType = "div">(props: PopoverContentProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: PopoverContentProps<T>): react.JSX.Element;
         displayName: string;
     };
     Header: {
-        <T extends react.ElementType = "div">(props: PopoverHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: PopoverHeaderProps<T>): react.JSX.Element;
         displayName: string;
     };
     Description: {
-        <T extends react.ElementType = "p">(props: PopoverDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "p">(props: PopoverDescriptionProps<T>): react.JSX.Element;
         displayName: string;
     };
     Arrow: {
-        <T extends react.ElementType = "svg">(props: PopoverArrowProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "svg">(props: PopoverArrowProps<T>): react.JSX.Element;
         displayName: string;
     };
     Close: {
-        <T extends react.ElementType = "button">(props: PopoverCloseProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "button">(props: PopoverCloseProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
-type SelectSize = 'small' | 'base' | 'large';
+/** 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';
 /**
- * Controls the panel's render width.
- *
- * - `'trigger'`: panel matches the trigger's measured width (form-aligned default)
- * - `'content'`: panel shrink-wraps the longest item, only enforcing the CSS min-width
- * - `number`: explicit pixel width
- * - `string`: any CSS width value (`'20rem'`, `'min(40ch, 100%)'`, etc.)
+ * 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`).
  */
-type SelectContentWidth = 'trigger' | 'content' | number | string;
-type SelectSlot = 'root';
-type SelectTriggerSlot = 'root';
-type SelectContentSlot = 'root';
-type SelectItemSlot = 'root';
+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.
+ *
+ * - `'trigger'`: panel matches the trigger's measured width (form-aligned default)
+ * - `'content'`: panel shrink-wraps the longest item, only enforcing the CSS min-width
+ * - `number`: explicit pixel width
+ * - `string`: any CSS width value (`'20rem'`, `'min(40ch, 100%)'`, etc.)
+ */
+type SelectContentWidth = 'trigger' | 'content' | number | string;
+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
@@ -1075,13 +2122,53 @@ interface SelectOwnProps {
  * `PolymorphicProps`.
  */
 type SelectProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectOwnProps & Pick<SelectProps$1, 'id' | 'value' | 'defaultValue' | 'onChange' | 'open' | 'defaultOpen' | 'onOpenChange' | 'disabled' | 'readOnly' | 'required' | 'name' | 'autoFocus'>>;
+/**
+ * State surface delivered to a render-function `indicator` (on the Trigger) or
+ * to {@link SelectIndicatorProps.children}. Lets consumers swap icons by open
+ * state without pulling the select context themselves. Mirrors the Accordion
+ * indicator's render state.
+ */
+interface SelectIndicatorRenderState {
+    isOpen: boolean;
+}
 interface SelectTriggerOwnProps {
+    /**
+     * Disclosure indicator rendered at the trailing edge of the trigger,
+     * after the value/placeholder. Defaults to a chevron that flips direction
+     * with the open state (parity with `Accordion.Indicator`).
+     *
+     * - omit / `true` → the default chevron
+     * - `false` / `null` → no indicator
+     * - a ReactNode → custom static icon (rendered in every state)
+     * - a render function receiving `{ isOpen }` → swap icons by open state
+     *
+     * Ignored when `children` is a render function: a render-prop `children` opts
+     * the trigger out of the built-in indicator and value wrapper entirely, so
+     * you can drop a standalone `<Select.Indicator />` into your own layout
+     * without a doubled chevron.
+     * @defaultValue true
+     */
+    indicator?: boolean | ReactNode | ((state: SelectIndicatorRenderState) => ReactNode);
     /** Per-slot class name overrides. */
     classNames?: ClassNamesMap<SelectTriggerSlot>;
     /** Per-slot HTML attribute overrides. */
     slotProps?: SlotPropsMap<SelectTriggerSlot>;
 }
 type SelectTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, SelectTriggerOwnProps & Pick<SelectTriggerProps$1, 'children' | 'placeholder'>>;
+interface SelectIndicatorOwnProps {
+    /**
+     * Override the default chevron. Accepts a ReactNode (rendered in every
+     * state) or a render function receiving the live `{ isOpen }` state — use
+     * the render-prop form to swap icons by open state without consuming the
+     * select context manually. Mirrors `Accordion.Indicator`.
+     */
+    children?: ReactNode | ((state: SelectIndicatorRenderState) => ReactNode);
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectIndicatorSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectIndicatorSlot>;
+}
+type SelectIndicatorProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, SelectIndicatorOwnProps>;
 interface SelectContentOwnProps {
     /** Per-slot class name overrides. */
     classNames?: ClassNamesMap<SelectContentSlot>;
@@ -1089,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>;
@@ -1117,44 +2211,686 @@ 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>;
     }
 }
 
 declare const Select: {
-    <T extends react.ElementType = "div">(props: SelectProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends react.ElementType = "div">(props: SelectProps<T>): react.JSX.Element;
     displayName: string;
 } & {
     Trigger: {
-        <T extends react.ElementType = "button">(props: SelectTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "button">(props: SelectTriggerProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        <T extends react.ElementType = "span">(props: SelectIndicatorProps<T>): react.JSX.Element;
         displayName: string;
     };
     Content: {
-        <T extends react.ElementType = "div">(props: SelectContentProps<T>): react_jsx_runtime.JSX.Element;
+        <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_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: SelectItemProps<T>): react.JSX.Element;
         displayName: string;
     };
     Group: {
-        <T extends react.ElementType = "div">(props: SelectGroupProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: SelectGroupProps<T>): react.JSX.Element;
         displayName: string;
     };
     Label: {
-        <T extends react.ElementType = "label">(props: SelectLabelProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "label">(props: SelectLabelProps<T>): react.JSX.Element;
         displayName: string;
     };
     Separator: {
-        <T extends react.ElementType = "div">(props: SelectSeparatorProps<T>): react_jsx_runtime.JSX.Element;
+        <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;
+    };
+};
+
+/** 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 {
+    /**
+     * 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
+     */
+    range?: false;
+    /**
+     * 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).
+     */
+    value?: number;
+    /**
+     * 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`
+     */
+    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;
+}
+/** 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;
+}
+/**
+ * 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 SliderOwnProps {
+    /**
+     * Lowest selectable value. Non-finite values fall back to the default.
+     * @defaultValue 0
+     */
+    min?: number;
+    /**
+     * 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
+     */
+    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;
     };
 };
@@ -1232,16 +2968,441 @@ declare module '../../core/theme' {
 }
 
 declare const Switch: {
-    <T extends react.ElementType = "button">(props: SwitchProps<T>): react_jsx_runtime.JSX.Element;
+    <T extends react.ElementType = "button">(props: SwitchProps<T>): react.JSX.Element;
     displayName: string;
 } & {
     Indicator: {
-        (props: SwitchIndicatorProps): react_jsx_runtime.JSX.Element;
+        (props: SwitchIndicatorProps): react.JSX.Element;
+        displayName: string;
+    };
+};
+
+/**
+ * Table is the catalog's first **TanStack-backed** component — its state core
+ * is `@tanstack/react-table`, not a Spar primitive. Consequently these public
+ * types are **v2-owned** (built on TanStack's generics) and carry no
+ * `Pick<SparTableProps, …>` boundary: there is no `SparTable` to pick from, so
+ * the `check-spar-pick.mjs` guard does not apply. See
+ * `docs/rfc-table-component.md` §3.2 and §9.
+ */
+/** Density scale → `data-size`. */
+type TableSize = 'xsmall' | 'small' | 'base';
+/** Horizontal cell content alignment → `data-align`. */
+type TableAlign = 'start' | 'center' | 'end';
+/** Pins a column to a table edge → `data-sticky`. */
+type TableStickySide = 'left' | 'right';
+/**
+ * Slot vocabulary for `classNames` / `slotProps`. Table is props-first with a
+ * single public component, so every anatomy node is reached through these
+ * slot keys rather than a public compound part (RFC §3.1, Tier 1.5).
+ */
+type TableSlot = 'root' | 'tableViewport' | 'table' | 'header' | 'headerRow' | 'headerCell' | 'headerContent' | 'sortTrigger' | 'sortIcon' | 'body' | 'row' | 'cell' | 'selectionCell' | 'expandCell' | 'expandButton' | 'expandedRow' | 'filterButton' | 'filterPanel' | 'pagination' | 'paginationInfo' | 'paginationNav' | 'paginationActions' | 'paginationSize' | 'paginationGoToPage' | 'empty' | 'loading';
+/**
+ * How a column reads its value out of a row:
+ *
+ * - `keyof TData` — a top-level property key.
+ * - `string` — a dot-path into nested data (`'user.role'`), resolved by
+ *   TanStack's `accessorKey`.
+ * - `(row) => unknown` — an arbitrary projection.
+ */
+type TableColumnAccessor<TData> = keyof TData | (string & {}) | ((row: TData) => unknown);
+/**
+ * Context handed to a column's {@link TableColumnFilter.render}. Table owns the
+ * filter **plumbing** — the header trigger, the `Popover`, the active-state dot,
+ * the TanStack wiring — and inverts control of the panel **content** to the
+ * consumer (the same inversion as `cell` and `expansion.render`).
+ *
+ * `value` is whatever shape the consumer's control writes via `setValue`; Table
+ * never interprets it beyond feeding TanStack's filter state and the
+ * {@link TableColumnFilter.isActive} predicate.
+ */
+interface TableColumnFilterContext<TData = unknown> {
+    /** Current filter value for this column (the last `setValue`, or `undefined`). */
+    value: unknown;
+    /** Write the column's filter value. Pass `undefined` to clear the filter. */
+    setValue: (value: unknown) => void;
+    /** Convenience for `setValue(undefined)`. */
+    clear: () => void;
+    /** The TanStack column — escape hatch for faceted values, sizing, etc. */
+    column: Column<TData, unknown>;
+    /** Close the filter popover (e.g. an apply-and-close button). */
+    close: () => void;
+}
+/**
+ * Built-in filter presets — the common cases, declarative and one-line. Table
+ * renders the control (with v2 components) and wires the matching:
+ *
+ * - `text`         → `Input`; case-insensitive substring match.
+ * - `select`       → single-choice `Select` dropdown; equality match.
+ * - `multi-select` → multi-choice `Select` dropdown; membership match.
+ * - `radio`        → inline `Radio` group (single choice); equality match.
+ * - `checkbox`     → inline `Checkbox` list (multi choice); membership match.
+ *
+ * For anything outside this set (range, date, combobox, async options, …) use
+ * the {@link TableColumnFilter.render} escape hatch instead.
+ */
+type TableColumnFilterType = 'text' | 'select' | 'multi-select' | 'radio' | 'checkbox';
+/** Option for the `select` / `multi-select` / `radio` / `checkbox` presets. */
+interface TableColumnFilterOption {
+    /** Visible label. */
+    label: ReactNode;
+    /** Value written to filter state (matched against the stringified cell value). */
+    value: string;
+}
+/**
+ * Per-column filter config. **Two tiers** (mirroring Mantine/Material React
+ * Table, AG Grid, MUI X — every mature table layers a shorthand under an escape
+ * hatch):
+ *
+ * 1. **Preset** — the 90% case in one line. Pass a {@link TableColumnFilterType}
+ *    string (`filter: 'text'`) or this object with `type` (+ `options` for the
+ *    choice presets). Table renders the control and picks the matching fn.
+ * 2. **Escape hatch** — pass `render` to own the panel content entirely (the
+ *    inversion of control used by `cell` / `expansion.render`). `type`/`options`
+ *    are ignored when `render` is present.
+ *
+ * Either way Table keeps owning the surrounding trigger + `Popover` (a real
+ * React portal — also the fix for the legacy sticky-cell z-index bug).
+ */
+interface TableColumnFilter<TData = unknown> {
+    /** Preset control to render. Ignored when {@link render} is supplied. */
+    type?: TableColumnFilterType;
+    /** Options for the `select` / `multi-select` / `radio` / `checkbox` presets. */
+    options?: TableColumnFilterOption[];
+    /** Placeholder for the `text` preset's input / `select` triggers. */
+    placeholder?: string;
+    /**
+     * Escape hatch: render the filter control yourself. Receives the column's
+     * value + setter (see {@link TableColumnFilterContext}). When present, the
+     * preset fields above are ignored.
+     */
+    render?: (ctx: TableColumnFilterContext<TData>) => ReactNode;
+    /**
+     * Whether a given filter value counts as "active" — drives the trigger's
+     * active indicator. Defaults to a sensible heuristic (non-empty string,
+     * non-empty array, or any non-nullish value); presets set this for you.
+     */
+    isActive?: (value: unknown) => boolean;
+    /**
+     * Row-matching predicate (client mode). Presets supply their own; for a
+     * custom `render` you can pass one here, else Table defaults by value shape:
+     * `string` → substring, `array` → membership, else strict equality. Ignored
+     * in `manual` mode, where the server matches. Signature is TanStack's
+     * `FilterFn`, so any built-in name or fn works.
+     */
+    filterFn?: FilterFn<TData>;
+}
+/**
+ * Open-ended, low-frequency per-column config. Frequently-used closed-set
+ * knobs (`align`, `sticky`, `width`) live top-level on {@link TableColumnDef};
+ * everything else flows through here so the public column def stays lean
+ * (RFC §3.2). Bound to TanStack's `columnDef.meta` via declaration merging
+ * below.
+ */
+interface TableColumnMeta {
+    /** Extra class on the body cell (`<td>`) owner node. */
+    className?: string;
+    /** Extra class on the header cell (`<th>`) owner node. */
+    headerClassName?: string;
+    /** Alignment override scoped to the header cell only. */
+    headerAlign?: TableAlign;
+}
+/**
+ * A v2-owned column definition. Internally adapted to TanStack's `ColumnDef`
+ * (RFC §3.2): `cell`/`header` are React render-props (never HTML strings),
+ * `accessor` covers key / dot-path / function, and `meta` is the escape hatch
+ * for the cell **container**.
+ */
+interface TableColumnDef<TData> {
+    /** Stable column identity. Required — also keys sort/filter state. */
+    id: string;
+    /** Header content: a node, or a render-prop receiving TanStack's context. */
+    header: ReactNode | ((ctx: HeaderContext<TData, unknown>) => ReactNode);
+    /** How the cell value is read. See {@link TableColumnAccessor}. */
+    accessor?: TableColumnAccessor<TData>;
+    /**
+     * Cell **content** render-prop. Returns a `ReactNode` — React reconciles it,
+     * so there is no `innerHTML`, no cache to invalidate (RFC §3.4). The cell
+     * **container** (`<td>`, padding, align, sticky, a11y) is owned by Table.
+     */
+    cell?: (ctx: CellContext<TData, unknown>) => ReactNode;
+    /** Opt this column into sorting (emits `aria-sort` + header keyboard). */
+    sortable?: boolean;
+    /**
+     * Attach a header filter. A preset string (`'text'`), a preset object
+     * (`{ type: 'select', options }`), or a custom `{ render }`. See
+     * {@link TableColumnFilter}.
+     */
+    filter?: TableColumnFilterType | TableColumnFilter<TData>;
+    /**
+     * Pin the column to an edge. Pinned columns must be **contiguous** against
+     * their edge — all `left` pins together at the start, all `right` pins
+     * together at the end. An unpinned column between two same-edge pins breaks
+     * the sticky-offset math (the later pin overlaps the gap); dev builds warn.
+     */
+    sticky?: TableStickySide;
+    /** Fixed column width (px). Feeds sticky-offset math and `col` sizing. */
+    width?: number;
+    /** Cell content alignment. */
+    align?: TableAlign;
+    /** Cell-container escape hatch → TanStack `columnDef.meta`. */
+    meta?: TableColumnMeta;
+}
+/** Controlled/uncontrolled triple shared by the stateful feature configs. */
+interface ControlledState<T> {
+    /** Controlled value. Pair with `onChange`. */
+    value?: T;
+    /** Uncontrolled initial value. */
+    defaultValue?: T;
+    /** Fires on every committed change to this slice. */
+    onChange?: (value: T) => void;
+}
+interface TableSortingConfig extends ControlledState<SortingState> {
+    /** Allow stacking multiple sort columns (shift-click). @defaultValue false */
+    multi?: boolean;
+}
+type TableFilteringConfig = ControlledState<ColumnFiltersState>;
+interface TableSelectionConfig extends ControlledState<RowSelectionState> {
+    /** `single` renders radios + caps selection at one row; `multiple` renders checkboxes + a select-all header. */
+    mode: 'single' | 'multiple';
+}
+interface TableExpansionConfig<TData> extends ControlledState<ExpandedState> {
+    /**
+     * Detail-panel renderer for an expanded row. Optional: when omitted, the
+     * Table is in **tree mode** — pair `expansion` with the top-level
+     * {@link TableProps.getSubRows} so expanding a row reveals its (flattened)
+     * sub-rows instead of a detail panel.
+     *
+     * `render` and `getSubRows` are mutually exclusive expansion shapes. Supplying
+     * both would draw the sub-rows *and* a detail panel for the same row, so when
+     * `getSubRows` is present the detail panel is suppressed (tree mode wins).
+     */
+    render?: (row: TData) => ReactNode;
+}
+interface TablePaginationConfig {
+    /** Rows per page. @defaultValue 10 */
+    pageSize?: number;
+    /** Controlled current page (server mode). */
+    pageIndex?: number;
+    /** Page-size options for the Select. @defaultValue [10, 25, 50, 100] */
+    pageSizeOptions?: number[];
+    /** Total row count across all pages — required in `manual` (server) mode. */
+    rowCount?: number;
+    /** Fires when page index or size changes. */
+    onChange?: (pagination: PaginationState) => void;
+}
+/**
+ * Bundled server data-request snapshot. Emitted from a single `onDataRequest`
+ * callback derived from the granular state slices, never a firehose
+ * `onStateChange` (RFC §3.3).
+ */
+interface TableDataRequest {
+    pagination: PaginationState;
+    sorting: SortingState;
+    filters: ColumnFiltersState;
+}
+/**
+ * Public props for `Table`. Props-first (RFC §3.1, Tier 1): a common table is
+ * a single `<Table data columns getRowId />` call. `getRowId` is **mandatory**
+ * — the single identity source TanStack's `RowSelectionState` keys on (RFC §2.3).
+ *
+ * `TData` defaults to `any` only so the non-generic `TableProps` alias resolves
+ * for the base/theme registry; real call sites infer `TData` from `data`.
+ */
+interface TableProps<TData = any> {
+    /** Row data. In `manual` mode this is the current server page. */
+    data: TData[];
+    /** Column definitions. See {@link TableColumnDef}. */
+    columns: TableColumnDef<TData>[];
+    /** Stable row identity (single source of truth). */
+    getRowId: (row: TData, index: number) => string;
+    /**
+     * Density scale.
+     * @defaultValue 'base'
+     */
+    size?: TableSize;
+    /**
+     * Zebra-stripe rows → `data-striped`.
+     * @defaultValue false
+     */
+    striped?: boolean;
+    /**
+     * Cell borders → `data-bordered`.
+     * @defaultValue false
+     */
+    bordered?: boolean;
+    /**
+     * Pin the header row during vertical scroll → `data-sticky-header`.
+     * @defaultValue false
+     */
+    stickyHeader?: boolean;
+    /**
+     * Server mode. When `true`, Table processes nothing in-memory — it maps to
+     * TanStack's `manualSorting`/`manualFiltering`/`manualPagination` and emits a
+     * single bundled `onDataRequest` (RFC §3.3).
+     * @defaultValue false
+     */
+    manual?: boolean;
+    /** Row selection (single/multiple + select-all). Composes Spar Checkbox/Radio. */
+    selection?: TableSelectionConfig;
+    /** Sorting (multi-sort opt-in). */
+    sorting?: TableSortingConfig;
+    /** Column filtering. Filter UIs render in a Spar `Popover`. */
+    filtering?: TableFilteringConfig;
+    /** Expandable rows with a render-prop body. */
+    expansion?: TableExpansionConfig<TData>;
+    /** Pagination. `true` enables it with defaults; an object configures it. */
+    pagination?: TablePaginationConfig | boolean;
+    /** Bundled server data-request callback (`manual` mode). See {@link TableDataRequest}. */
+    onDataRequest?: (request: TableDataRequest) => void;
+    /**
+     * Loading state → `data-loading` + a loading overlay.
+     * @defaultValue false
+     */
+    loading?: boolean;
+    /** Content rendered when there are no rows. */
+    emptyState?: ReactNode;
+    /**
+     * Sub-row reader for **tree data** (feeds TanStack `getSubRows`). Pair it with
+     * `expansion` (sans `render`) so expanding a row reveals its flattened
+     * sub-rows. When `getSubRows` is omitted, expansion falls back to the
+     * detail-panel mode driven by `expansion.render`. Supplying both keeps tree
+     * mode and suppresses the detail panel.
+     */
+    getSubRows?: (row: TData) => TData[] | undefined;
+    /**
+     * Escape hatch for the rare imperative need — receives the TanStack table
+     * instance (RFC §2.3: controlled props + an optional instance ref, never an
+     * imperative `@Method` surface). Also the access point for `getExportRows()`.
+     */
+    tableRef?: Ref<Table$1<TData> | null>;
+    /** Extra class on the root scroll container. */
+    className?: string;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<TableSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<TableSlot>;
+    /** Ref to the root scroll container. */
+    ref?: Ref<HTMLDivElement>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Table: ComponentThemeConfig<TableProps, TableSlot>;
+    }
+}
+declare module '@tanstack/react-table' {
+    interface ColumnMeta<TData extends _tanstack_react_table.RowData, TValue> {
+        align?: TableAlign;
+        sticky?: TableStickySide;
+        width?: number;
+        className?: string;
+        headerClassName?: string;
+        headerAlign?: TableAlign;
+        filter?: TableColumnFilterType | TableColumnFilter<TData>;
+    }
+}
+
+declare const Table: {
+    <TData>(props: TableProps<TData>): react.JSX.Element;
+    displayName: string;
+};
+
+/**
+ * Project the table's current rows to plain value records keyed by column id —
+ * the data-only export surface (RFC §5). Formatting and file generation are the
+ * consumer's job; Table ships no export engine. Reach it via the `tableRef`
+ * instance: `getExportRows(tableRef.current)`.
+ *
+ * **Scope depends on mode.** In **client** mode this is every filtered + sorted
+ * row *across all pages* (pre-pagination), since Table holds the full dataset.
+ * In **server (`manual`)** mode Table only ever holds the current page, so the
+ * export is limited to the rows currently loaded — fetch the full result set
+ * yourself if you need to export beyond the visible page.
+ */
+declare const getExportRows: <TData>(table: Table$1<TData> | null | undefined) => Record<string, unknown>[];
+
+type TabsSize = 'small' | 'base' | 'large';
+type TabsActivationMode = TabsActivationMode$1;
+type TabsVariant = 'primary' | 'info' | 'neutral';
+type TabsAppearance = 'basic' | 'compact' | 'divided' | 'expanded';
+type TabsTriggerRenderProps = Pick<TabsTriggerRenderProps$1, 'isSelected' | 'select' | 'disabled' | 'isFocused' | 'orientation'>;
+type TabsSlot = 'root';
+type TabsListSlot = 'root';
+type TabsTriggerSlot = 'root';
+type TabsContentSlot = 'root';
+interface TabsOwnProps {
+    /**
+     * Size scale. Cascades to `Tabs.Trigger` via context.
+     * @defaultValue 'base'
+     */
+    size?: TabsSize;
+    /**
+     * Color variant used by the active tab treatment.
+     * @defaultValue 'primary'
+     */
+    variant?: TabsVariant;
+    /**
+     * Visual tab style.
+     * @defaultValue 'basic'
+     */
+    appearance?: TabsAppearance;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<TabsSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<TabsSlot>;
+}
+type TabsProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, TabsOwnProps & Pick<TabsProps$1, 'id' | 'value' | 'defaultValue' | 'onValueChange' | 'orientation' | 'activationMode'>>;
+interface TabsListOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<TabsListSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<TabsListSlot>;
+}
+type TabsListProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, TabsListOwnProps & Pick<TabsListProps$1, 'children'>>;
+interface TabsTriggerOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<TabsTriggerSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<TabsTriggerSlot>;
+    /** Compound children, or a render function exposing Spar's per-trigger state. */
+    children?: ReactNode | ((state: TabsTriggerRenderProps) => ReactNode);
+}
+type TabsTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, TabsTriggerOwnProps & Pick<TabsTriggerProps$1, 'value' | 'disabled' | 'autoFocus'>>;
+interface TabsContentOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<TabsContentSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<TabsContentSlot>;
+}
+type TabsContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, TabsContentOwnProps & Pick<TabsContentProps$1, 'value' | 'forceMount'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Tabs: ComponentThemeConfig<TabsProps, TabsSlot>;
+        TabsList: ComponentThemeConfig<TabsListProps, TabsListSlot>;
+        TabsTrigger: ComponentThemeConfig<TabsTriggerProps, TabsTriggerSlot>;
+        TabsContent: ComponentThemeConfig<TabsContentProps, TabsContentSlot>;
+    }
+}
+
+declare const Tabs: {
+    <T extends react.ElementType = "div">(props: TabsProps<T>): react.JSX.Element;
+    displayName: string;
+} & {
+    List: {
+        <T extends react.ElementType = "div">(props: TabsListProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Trigger: {
+        <T extends react.ElementType = "button">(props: TabsTriggerProps<T>): react.JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        <T extends react.ElementType = "div">(props: TabsContentProps<T>): react.JSX.Element;
         displayName: string;
     };
 };
 
-type TooltipVariant = 'dark' | 'white' | 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+type TooltipVariant = 'white' | 'dark' | 'info' | 'success' | 'warning' | 'danger' | 'neutral';
 type TooltipTriggerSlot = 'root';
 type TooltipContentSlot = 'root';
 type TooltipHeaderSlot = 'root';
@@ -1268,7 +3429,7 @@ type TooltipTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'b
 interface TooltipContentOwnProps {
     /**
      * Color variant.
-     * @defaultValue 'dark'
+     * @defaultValue 'white'
      */
     variant?: TooltipVariant;
     /** Per-slot extra classes. */
@@ -1309,33 +3470,122 @@ declare module '../../core/theme' {
 }
 
 declare const Tooltip: {
-    ({ children, id, open, defaultOpen, onOpenChange, delay, hideDelay, disabled }: TooltipProps): react_jsx_runtime.JSX.Element;
+    ({ children, id, open, defaultOpen, onOpenChange, delay, hideDelay, disabled }: TooltipProps): react.JSX.Element;
     displayName: string;
 } & {
     Provider: {
-        ({ children, delayDuration, skipDelayDuration, disableHoverableContent }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
+        ({ children, delayDuration, skipDelayDuration, disableHoverableContent }: TooltipProviderProps): react.JSX.Element;
         displayName: string;
     };
     Trigger: {
-        <T extends react.ElementType = "button">(props: TooltipTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "button">(props: TooltipTriggerProps<T>): react.JSX.Element;
         displayName: string;
     };
     Content: {
-        <T extends react.ElementType = "div">(props: TooltipContentProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: TooltipContentProps<T>): react.JSX.Element;
         displayName: string;
     };
     Header: {
-        <T extends react.ElementType = "div">(props: TooltipHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "div">(props: TooltipHeaderProps<T>): react.JSX.Element;
         displayName: string;
     };
     Description: {
-        <T extends react.ElementType = "p">(props: TooltipDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "p">(props: TooltipDescriptionProps<T>): react.JSX.Element;
         displayName: string;
     };
     Arrow: {
-        <T extends react.ElementType = "svg">(props: TooltipArrowProps<T>): react_jsx_runtime.JSX.Element;
+        <T extends react.ElementType = "svg">(props: TooltipArrowProps<T>): react.JSX.Element;
         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, Badge, type BadgeAppearance, type BadgeProps, type BadgeSize, type BadgeSlot, type BadgeVariant, Button, type ButtonAppearance, type ButtonProps, type ButtonSize, type ButtonSlot, type ButtonVariant, Checkbox, type CheckboxIndicatorProps, type CheckboxIndicatorRenderProps, type CheckboxProps, type CheckboxRenderProps, type CheckboxSize, type CheckboxSlot, type CheckboxType, type ClassNamesMap, type ColorMode, type ComponentName, type ComponentThemeConfig, type ComponentThemeRegistry, type ComponentsThemeMap, type DataSlotName, Drawer, type DrawerBodyProps, type DrawerCloseButtonProps, 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 InputContainerProps, type InputFieldProps, type InputPrefixProps, type InputProps, type InputSize, type InputSuffixProps, 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, type RadioType, Select, type SelectContentProps, type SelectGroupProps, type SelectItemProps, type SelectLabelProps, type SelectProps, type SelectSeparatorProps, type SelectSize, type SelectTriggerProps, type SlotClassNames, type SlotPropsMap, type StateOnlyComponentThemeConfig$1 as StateOnlyComponentThemeConfig, Switch, type SwitchIndicatorProps, type SwitchIndicatorRenderProps, type SwitchProps, type SwitchRenderProps, type SwitchSize, type SwitchSlot, type SwitchVariant, TakeoffSparProvider, type TakeoffSparProviderProps, type TakeoffSparProviderValue, type ThemeValue, 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, useComponentTheme, useTheme };
+type ToastVariant = AlertVariant;
+type ToastAppearance = AlertAppearance;
+type ToastSlot = 'root';
+type ToasterSlot = 'root';
+type ToastData = ToastData$1;
+type ToastOptions = ToastOptions$1;
+interface ToasterOwnProps {
+    toaster: ToasterController;
+    appearance?: ToastAppearance;
+    closeLabel?: string;
+    overlap?: boolean;
+    classNames?: ClassNamesMap<ToasterSlot>;
+    slotProps?: SlotPropsMap<ToasterSlot>;
+    children?: (toast: ToastData) => ReactNode;
+}
+type ToasterProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, ToasterOwnProps & Pick<ToasterProps$1, 'label' | 'hotkey'>>;
+interface ToastOwnProps {
+    toast: ToastData;
+    toaster?: ToasterController;
+    appearance?: ToastAppearance;
+    closeLabel?: string;
+    classNames?: ClassNamesMap<ToastSlot>;
+    slotProps?: SlotPropsMap<ToastSlot>;
+}
+type ToastProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, ToastOwnProps & {
+    children?: ReactNode;
+}>;
+
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Toaster: ComponentThemeConfig<ToasterProps, ToasterSlot>;
+        Toast: ComponentThemeConfig<ToastProps, ToastSlot>;
+    }
+}
+
+declare const Toaster: {
+    <T extends ElementType = "div">(props: ToasterProps<T>): react.JSX.Element;
+    displayName: string;
+};
+
+declare const Toast: {
+    <T extends ElementType = "div">(props: ToastProps<T>): react.JSX.Element;
+    displayName: string;
+};
+
+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;
+};
+
+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, getExportRows, useComponentTheme, useTheme };