@takeoff-ui/react-spar 0.1.0-beta.0

package/dist/index.d.cts

@@ -0,0 +1,1352 @@
+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, SelectValueProps as SelectValueProps$1, SelectContentProps as SelectContentProps$1, SelectItemProps as SelectItemProps$1, SelectGroupProps as SelectGroupProps$1, SelectLabelProps as SelectLabelProps$1, SelectItemTextProps as SelectItemTextProps$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';
+
+/** Per-slot class map declared by a component base. Every slot is required. */
+type SlotClassNames<TSlot extends string> = Record<TSlot, string>;
+/** Per-slot className override map. Consumers only fill the slots they extend. */
+type ClassNamesMap<TSlot extends string> = Partial<Record<TSlot, string>>;
+/**
+ * Per-slot HTML-attribute override map. Defaults to a generic `HTMLAttributes`
+ * shape; components with element-specific slots may narrow `TAttrs`.
+ */
+type SlotPropsMap<TSlot extends string, TAttrs extends object = HTMLAttributes<HTMLElement>> = Partial<Record<TSlot, TAttrs>>;
+/**
+ * Native HTML props that every takeoff-v2 wrapper owns — the wrapper-typed
+ * versions (`classNames`, `slotProps`) always replace the native names. Apply
+ * via {@link TakeoffHTMLProps} as the base for wrapper Props interfaces.
+ *
+ * Component-specific extra omits (e.g. native `defaultValue`/`onChange` when
+ * a headless prop owns the same name) are added at the call site.
+ */
+type TakeoffSlotOverrides = 'classNames' | 'slotProps';
+/**
+ * Native props of `T` minus the props takeoff-v2 always owns. The shared base
+ * for wrapper Props interfaces — pairs with `Pick<SparXxxProps, ...>` to form
+ * the public boundary.
+ */
+type TakeoffHTMLProps<T extends ElementType> = Omit<ComponentPropsWithoutRef<T>, TakeoffSlotOverrides>;
+
+type KebabCase<S extends string> = S extends `${infer First}${infer Rest}` ? First extends Lowercase<First> ? `${First}${KebabCase<Rest>}` : `-${Lowercase<First>}${KebabCase<Rest>}` : S;
+type DataSlotName<TSlot extends string> = KebabCase<TSlot>;
+
+/**
+ * Per-component override config carried on the provider's `components` map.
+ * The provider applies its layers below the instance, so an instance prop
+ * always wins on conflict and the canonical `tk-*` class is never dropped.
+ *
+ * @typeParam TProps      Public props of the component this entry targets.
+ * @typeParam TSlot       Slot key union; defaults to `'root'` for single-slot entries.
+ * @typeParam TSlotProps  Per-slot attribute map; narrow per element type when needed.
+ */
+interface ComponentThemeConfig<TProps = unknown, TSlot extends string = 'root', TSlotProps extends SlotPropsMap<TSlot, object> = SlotPropsMap<TSlot>> {
+    /** Applied only when the instance does not set the prop. */
+    defaultProps?: Partial<TProps>;
+    /** Shortcut equivalent to `classNames.root`; concatenated, never replaces the canonical class. */
+    className?: string;
+    /** Per-slot extra classes; concatenated, never replaces the canonical class. */
+    classNames?: ClassNamesMap<TSlot>;
+    /** Per-slot HTML-attribute overrides; shallow-merged below the wrapper's canonical attrs. */
+    slotProps?: TSlotProps;
+}
+/**
+ * Provider override config for **state-only roots** — components whose root
+ * renders no DOM (e.g. `Drawer`, `Tooltip`). Styling layers (`className`,
+ * `classNames`, `slotProps`) have no DOM target on a state-only root and
+ * would be silently dropped, so this variant exposes only `defaultProps`.
+ *
+ * Use this in the registry for any root whose JSX is a pure context
+ * provider. Children parts (e.g. `Drawer.Panel`, `Tooltip.Content`) still
+ * use {@link ComponentThemeConfig} because they render real DOM.
+ *
+ * @typeParam TProps  Public props of the state-only root.
+ */
+interface StateOnlyComponentThemeConfig$1<TProps = unknown> {
+    /** Applied only when the instance does not set the prop. */
+    defaultProps?: Partial<TProps>;
+}
+/**
+ * Registry of every component name the provider can override. Declared as
+ * `interface` so consumers can augment it via TypeScript declaration merging.
+ */
+interface ComponentThemeRegistry {
+}
+type ComponentName = keyof ComponentThemeRegistry;
+/** Provider-facing override map. Each entry is optional. */
+type ComponentsThemeMap = {
+    [K in ComponentName]?: ComponentThemeRegistry[K];
+};
+
+type ColorMode = 'light' | 'dark';
+interface TakeoffSparProviderValue {
+    colorMode: ColorMode;
+    locale?: string;
+    components?: ComponentsThemeMap;
+}
+interface ThemeValue {
+    colorMode: ColorMode;
+}
+interface TakeoffSparProviderProps extends Partial<TakeoffSparProviderValue> {
+    children: ReactNode;
+}
+/**
+ * Top-level provider for Takeoff React components. Writes `data-theme` and
+ * `lang` to `document.documentElement` so styling and language attributes
+ * propagate to portal-mounted descendants (Dialog, Popover, Tooltip, …) and
+ * are picked up by global CSS selectors.
+ *
+ * Renders no DOM of its own — only a React context. For SSR apps, set
+ * `<html data-theme="…" lang="…">` on the server (e.g. with a small inline
+ * 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;
+/**
+ * Read the active theme value. The provider is **optional**: when no
+ * `TakeoffSparProvider` ancestor is present, the default theme
+ * (`{ colorMode: 'light' }`) is returned and a one-time dev-mode warning is
+ * emitted. Wrap the app in `TakeoffSparProvider` to customize `colorMode` or
+ * `locale`.
+ */
+declare const useTheme: () => ThemeValue;
+/**
+ * Read the provider override config for a known component name. The return
+ * type narrows by key: `useComponentTheme('Accordion')` returns
+ * `ComponentThemeConfig<AccordionProps> | undefined`. Unknown names are a
+ * compile-time error.
+ *
+ * The provider is **optional** — when no `TakeoffSparProvider` ancestor is
+ * present, this hook returns `undefined` silently and the component falls
+ * back to its author defaults. No warning is emitted because the absence of
+ * a provider-level override is a legitimate use case (component used
+ * standalone).
+ */
+declare const useComponentTheme: <K extends ComponentName>(componentName: K) => ComponentThemeRegistry[K] | undefined;
+
+/**
+ * Visual grouping vocabulary mirrored from Takeoff Core (`tk-accordion`).
+ */
+type AccordionType = 'grouped' | 'divided';
+/**
+ * Density mode. `'compact'` reduces vertical rhythm; pairs with any
+ * {@link AccordionType}. Default `'default'`.
+ */
+type AccordionMode = 'default' | 'compact';
+type AccordionSize = 'base' | 'large';
+type AccordionHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type AccordionValue = string | number;
+/**
+ * Current panel identifier(s). Scalar in single mode, array when
+ * `multiple` is set.
+ */
+type AccordionCurrentValue = AccordionValue | AccordionValue[];
+type AccordionValueChangeHandler = (next: AccordionCurrentValue) => void;
+type AccordionSlot = 'root';
+type AccordionItemSlot = 'root';
+type AccordionHeaderSlot = 'root';
+type AccordionTriggerSlot = 'root' | 'startContent' | 'title';
+type AccordionIndicatorSlot = 'root';
+type AccordionContentSlot = 'root';
+/**
+ * State surface delivered to {@link AccordionIndicatorProps.children} when
+ * passed as a render function. Lets consumers swap icons by open state without
+ * pulling the item context themselves.
+ */
+interface AccordionIndicatorRenderState {
+    isOpen: boolean;
+}
+/**
+ * Visual + slot props owned by takeoff-v2 for the Accordion root. Cascades to
+ * descendants through the visual context (`type`, `mode`, `size`, arrows).
+ */
+interface AccordionOwnProps {
+    /**
+     * Visual grouping.
+     * @defaultValue 'grouped'
+     */
+    type?: AccordionType;
+    /**
+     * Density mode. Pairs with any {@link AccordionType}.
+     * @defaultValue 'default'
+     */
+    mode?: AccordionMode;
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: AccordionSize;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<AccordionSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<AccordionSlot>;
+}
+/**
+ * Public props for the Accordion root. Polymorphic via `as`; ref and the
+ * native attributes of the rendered element are inherited from Spar's
+ * `PolymorphicProps`.
+ */
+type AccordionProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, AccordionOwnProps & Pick<AccordionProps$1, 'multiple' | 'value' | 'defaultValue' | 'onValueChange' | 'collapsible' | 'disabled' | 'orientation'>>;
+interface AccordionItemOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<AccordionItemSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<AccordionItemSlot>;
+}
+type AccordionItemProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, AccordionItemOwnProps & Pick<AccordionItemProps$1, 'value' | 'disabled'>>;
+interface AccordionHeaderOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<AccordionHeaderSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<AccordionHeaderSlot>;
+}
+type AccordionHeaderProps<T extends ElementType = 'h3'> = PolymorphicProps<'h3', T, AccordionHeaderOwnProps & Pick<AccordionHeaderProps$1, 'level'>>;
+interface AccordionTriggerOwnProps {
+    /**
+     * Leading content rendered before the title — typically an icon, but
+     * accepts any node. The wrapper element (class + `data-slot`) is invariant;
+     * only the inner node is consumer-supplied.
+     */
+    startContent?: ReactNode;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<AccordionTriggerSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<AccordionTriggerSlot>;
+}
+type AccordionTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, AccordionTriggerOwnProps>;
+interface AccordionIndicatorOwnProps {
+    /**
+     * 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
+     * item context manually.
+     */
+    children?: ReactNode | ((state: AccordionIndicatorRenderState) => ReactNode);
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<AccordionIndicatorSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<AccordionIndicatorSlot>;
+}
+type AccordionIndicatorProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, AccordionIndicatorOwnProps>;
+interface AccordionContentOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<AccordionContentSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<AccordionContentSlot>;
+}
+type AccordionContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, AccordionContentOwnProps & Pick<AccordionContentProps$1, 'forceMount' | 'onBeforeMatch'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Accordion: ComponentThemeConfig<AccordionProps>;
+        AccordionItem: ComponentThemeConfig<AccordionItemProps>;
+        AccordionHeader: ComponentThemeConfig<AccordionHeaderProps>;
+        AccordionTrigger: ComponentThemeConfig<AccordionTriggerProps, AccordionTriggerSlot>;
+        AccordionIndicator: ComponentThemeConfig<AccordionIndicatorProps, AccordionIndicatorSlot>;
+        AccordionContent: ComponentThemeConfig<AccordionContentProps>;
+    }
+}
+
+declare const Accordion: {
+    <T extends react.ElementType = "div">(props: AccordionProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Item: {
+        <T extends react.ElementType = "div">(props: AccordionItemProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        <T extends react.ElementType = "h3">(props: AccordionHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Trigger: {
+        <T extends react.ElementType = "button">(props: AccordionTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        <T extends react.ElementType = "span">(props: AccordionIndicatorProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        <T extends react.ElementType = "div">(props: AccordionContentProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+type BadgeVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning' | 'verified' | 'purple' | 'cyan' | 'business';
+type BadgeAppearance = 'filled' | 'filledLight' | 'outlined' | 'text';
+type BadgeSize = 'small' | 'base' | 'large';
+type BadgeSlot = 'root' | 'label' | 'icon';
+interface BadgeProps extends Omit<TakeoffHTMLProps<'span'>, 'children'> {
+    /**
+     * Color variant.
+     * @defaultValue 'primary'
+     */
+    variant?: BadgeVariant;
+    /**
+     * Visual appearance.
+     * @defaultValue 'filled'
+     */
+    appearance?: BadgeAppearance;
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: BadgeSize;
+    /**
+     * Renders a pill-shaped badge with fully rounded corners.
+     * @defaultValue false
+     */
+    rounded?: boolean;
+    /**
+     * Renders a minimal colored dot (6×6px) with no content.
+     * When true, children, startContent, and endContent are ignored.
+     * @defaultValue false
+     */
+    dot?: boolean;
+    /**
+     * Content rendered before children — typically an icon.
+     */
+    startContent?: ReactNode;
+    /**
+     * Content rendered after children.
+     */
+    endContent?: ReactNode;
+    /** Badge content. */
+    children?: ReactNode;
+    /** Ref forwarded to the root span element. */
+    ref?: Ref<HTMLSpanElement>;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<BadgeSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<BadgeSlot>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Badge: ComponentThemeConfig<BadgeProps, BadgeSlot>;
+    }
+}
+
+declare const Badge: {
+    (props: BadgeProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type ButtonVariant = 'primary' | 'secondary' | 'neutral' | 'info' | 'success' | 'danger' | 'warning' | 'white' | 'black';
+type ButtonAppearance = 'filled' | 'filledLight' | 'outlined' | 'text';
+type ButtonSize = 'small' | 'base' | 'large';
+type ButtonSlot = 'root' | 'content' | 'label' | 'spinner';
+/**
+ * Visual + slot props owned by takeoff-v2 (not exposed by Spar).
+ */
+interface ButtonOwnProps {
+    /**
+     * Color variant.
+     * @defaultValue 'primary'
+     */
+    variant?: ButtonVariant;
+    /**
+     * Visual appearance.
+     * @defaultValue 'filled'
+     */
+    appearance?: ButtonAppearance;
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: ButtonSize;
+    /**
+     * Renders a pill-shaped (circular) button. Ideal for icon-only actions.
+     * @defaultValue false
+     */
+    rounded?: boolean;
+    /**
+     * Content rendered before children — typically an icon, but accepts any node
+     * (spinner, badge, kbd, etc.). Wrapped in the `icon` slot.
+     */
+    startContent?: ReactNode;
+    /**
+     * Content rendered after children. Same shape as `startContent`.
+     */
+    endContent?: ReactNode;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<ButtonSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<ButtonSlot>;
+}
+/**
+ * Public props for the Button. Polymorphic via `as` (e.g. render as `<a>` for
+ * 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'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Button: ComponentThemeConfig<ButtonProps, ButtonSlot>;
+    }
+}
+
+declare const Button: {
+    <T extends ElementType = "button">(props: ButtonProps<T>): react_jsx_runtime.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
+ * Spar's shape verbatim — `checked` is the tri-state `CheckedState` here.
+ * Compound consumers should reach for `Checkbox.Indicator` instead so they
+ * receive the takeoff-spar `boolean` + `indeterminate` split.
+ */
+type CheckboxRenderProps = CheckboxRenderProps$1;
+/**
+ * Render props passed to `Checkbox.Indicator` function-children. Exposes the
+ * takeoff-spar split rather than Spar's tri-state, matching the example in
+ * `packages/react-spar/docs/coding-standards.md`.
+ */
+interface CheckboxIndicatorRenderProps {
+    checked: boolean;
+    indeterminate: boolean;
+}
+interface CheckboxOwnProps {
+    /**
+     * Controlled checked state. Pair with `onChange`.
+     * @remarks `indeterminate` overrides this when set to `true`.
+     */
+    checked?: boolean;
+    /**
+     * Uncontrolled initial checked state.
+     * @defaultValue false
+     * @remarks `indeterminate` overrides this when set to `true`.
+     */
+    defaultChecked?: boolean;
+    /**
+     * Indeterminate (mixed) visual + ARIA state. Overrides `checked` /
+     * `defaultChecked` when `true`; emits `aria-checked="mixed"`.
+     *
+     * Dynamic toggling of `indeterminate` is only fully reactive in controlled
+     * mode. In uncontrolled mode, set it at the initial render and clear it
+     * from your own state in response to `onChange`.
+     * @defaultValue false
+     */
+    indeterminate?: boolean;
+    /**
+     * Fired when the user toggles the checkbox. Indeterminate transitions to
+     * `true` on the first toggle, so the callback's argument is always a
+     * plain `boolean`.
+     */
+    onChange?: (checked: boolean) => void;
+    /**
+     * Marks the checkbox as visually invalid.
+     * @defaultValue false
+     */
+    invalid?: boolean;
+    /**
+     * Size scale.
+     * @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. */
+    slotProps?: SlotPropsMap<CheckboxSlot>;
+    /**
+     * Compound children for the checkbox anatomy, or a render function
+     * exposing Spar's state. Compound children are the canonical composition
+     * path; the render-prop is preserved for parity with Spar's leaf primitive.
+     */
+    children?: ReactNode | ((state: CheckboxRenderProps$1) => ReactNode);
+}
+/**
+ * Public props for `Checkbox`. Polymorphic via `as` — defaults to the Spar
+ * primitive's `<span role="checkbox">` element.
+ */
+type CheckboxProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, CheckboxOwnProps & Pick<CheckboxProps$1, 'disabled' | 'readOnly' | 'required' | 'name' | 'value' | 'form' | 'autoFocus'>>;
+interface CheckboxIndicatorProps extends Omit<ComponentPropsWithoutRef<'span'>, 'children'> {
+    /**
+     * Indicator content. When omitted, the built-in placeholder check / dash
+     * glyph is rendered inside an `icon` slot (driven by `indeterminate`).
+     * When a function, receives the current `checked` and `indeterminate`
+     * state from the root and its return value replaces the default slot.
+     * Passing a `ReactNode` likewise replaces the inner slot entirely — the
+     * consumer becomes responsible for any `data-slot="icon"` wrapper they
+     * need for theming.
+     */
+    children?: ReactNode | ((state: CheckboxIndicatorRenderProps) => ReactNode);
+    ref?: Ref<HTMLSpanElement>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Checkbox: ComponentThemeConfig<CheckboxProps, CheckboxSlot>;
+    }
+}
+
+declare const Checkbox: {
+    <T extends react.ElementType = "span">(props: CheckboxProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Indicator: {
+        (props: CheckboxIndicatorProps): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+/**
+ * Side from which the drawer slides in.
+ * @defaultValue 'right'
+ */
+type DrawerPlacement = 'left' | 'right' | 'top' | 'bottom' | 'full-screen';
+type DrawerOverlaySlot = 'root';
+type DrawerPanelSlot = 'root';
+type DrawerHeaderSlot = 'root';
+type DrawerTitleSlot = 'root';
+type DrawerDescriptionSlot = 'root';
+type DrawerBodySlot = 'root';
+type DrawerFooterSlot = 'root';
+type DrawerCloseButtonSlot = '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
+ * polymorphic `as`, no native HTML props, no `className` / `classNames` /
+ * `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'> {
+    /** Side the drawer slides in from. */
+    placement?: DrawerPlacement;
+    /** Whether the drawer can be dismissed by clicking outside or pressing Escape. @defaultValue true */
+    dismissable?: 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 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;
+    classNames?: ClassNamesMap<DrawerOverlaySlot>;
+    slotProps?: SlotPropsMap<DrawerOverlaySlot>;
+}
+type DrawerOverlayProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerOverlayOwnProps & Pick<DialogOverlayProps, 'container'>>;
+interface DrawerPanelOwnProps {
+    classNames?: ClassNamesMap<DrawerPanelSlot>;
+    slotProps?: SlotPropsMap<DrawerPanelSlot>;
+}
+type DrawerPanelProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerPanelOwnProps & Pick<DialogContentProps, 'container' | 'trapFocus' | 'restoreFocus' | 'initialFocus' | 'finalFocus' | 'onOpenAutoFocus' | 'onCloseAutoFocus' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onInteractOutside'>>;
+type DrawerHeaderType = 'basic' | 'divided' | 'light' | 'dark' | 'primary';
+interface DrawerHeaderOwnProps {
+    /** Type of the header. @defaultValue 'basic' */
+    headerType?: DrawerHeaderType;
+    classNames?: ClassNamesMap<DrawerHeaderSlot>;
+    slotProps?: SlotPropsMap<DrawerHeaderSlot>;
+}
+type DrawerHeaderProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerHeaderOwnProps>;
+interface DrawerTitleOwnProps {
+    classNames?: ClassNamesMap<DrawerTitleSlot>;
+    slotProps?: SlotPropsMap<DrawerTitleSlot>;
+}
+type DrawerTitleProps<T extends ElementType = 'h2'> = PolymorphicProps<'h2', T, DrawerTitleOwnProps & Pick<DialogTitleProps, 'level'>>;
+interface DrawerDescriptionOwnProps {
+    classNames?: ClassNamesMap<DrawerDescriptionSlot>;
+    slotProps?: SlotPropsMap<DrawerDescriptionSlot>;
+}
+type DrawerDescriptionProps<T extends ElementType = 'p'> = PolymorphicProps<'p', T, DrawerDescriptionOwnProps>;
+interface DrawerBodyOwnProps {
+    classNames?: ClassNamesMap<DrawerBodySlot>;
+    slotProps?: SlotPropsMap<DrawerBodySlot>;
+}
+type DrawerBodyProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerBodyOwnProps>;
+type DrawerFooterType = 'basic' | 'divided' | 'light';
+interface DrawerFooterOwnProps {
+    /** Type of the footer. @defaultValue 'basic' */
+    footerType?: DrawerFooterType;
+    classNames?: ClassNamesMap<DrawerFooterSlot>;
+    slotProps?: SlotPropsMap<DrawerFooterSlot>;
+}
+type DrawerFooterProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, DrawerFooterOwnProps>;
+interface DrawerCloseButtonOwnProps {
+    classNames?: ClassNamesMap<DrawerCloseButtonSlot>;
+    slotProps?: SlotPropsMap<DrawerCloseButtonSlot>;
+}
+type DrawerCloseButtonProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, DrawerCloseButtonOwnProps & Pick<DialogCloseProps, 'children'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Drawer: StateOnlyComponentThemeConfig<DrawerProps>;
+        DrawerTrigger: ComponentThemeConfig<DrawerTriggerProps>;
+        DrawerOverlay: ComponentThemeConfig<DrawerOverlayProps>;
+        DrawerPanel: ComponentThemeConfig<DrawerPanelProps>;
+        DrawerHeader: ComponentThemeConfig<DrawerHeaderProps>;
+        DrawerTitle: ComponentThemeConfig<DrawerTitleProps>;
+        DrawerDescription: ComponentThemeConfig<DrawerDescriptionProps>;
+        DrawerBody: ComponentThemeConfig<DrawerBodyProps>;
+        DrawerFooter: ComponentThemeConfig<DrawerFooterProps>;
+        DrawerCloseButton: ComponentThemeConfig<DrawerCloseButtonProps>;
+    }
+}
+
+declare const Drawer: {
+    (props: DrawerProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Trigger: {
+        <T extends react.ElementType = "button">(props: DrawerTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Overlay: {
+        <T extends react.ElementType = "div">(props: DrawerOverlayProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Panel: {
+        <T extends react.ElementType = "div">(props: DrawerPanelProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        <T extends react.ElementType = "div">(props: DrawerHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Title: {
+        <T extends react.ElementType = "h2">(props: DrawerTitleProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "p">(props: DrawerDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        <T extends react.ElementType = "div">(props: DrawerBodyProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        <T extends react.ElementType = "div">(props: DrawerFooterProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    CloseButton: {
+        <T extends react.ElementType = "button">(props: DrawerCloseButtonProps<T>): react_jsx_runtime.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>;
+}
+/**
+ * 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' | '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_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Label: {
+        <T extends react.ElementType = "label">(props: FieldLabelProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "div">(props: FieldDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    ErrorMessage: {
+        <T extends react.ElementType = "div">(props: FieldErrorMessageProps<T>): react_jsx_runtime.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`
+ * cascades to descendants through a visual context so InputField renders at
+ * the same scale without consumers having to repeat the prop.
+ */
+interface InputOwnProps {
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: InputSize;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputSlot>;
+}
+/**
+ * Public props for the Input root. Polymorphic via `as`; ref and the native
+ * attributes of the rendered element are inherited from Spar's
+ * `PolymorphicProps`.
+ */
+type InputProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, InputOwnProps & Pick<InputProps$1, 'id' | 'invalid' | 'disabled' | 'required' | 'readOnly'>>;
+interface InputFieldOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputFieldSlot>;
+    /** Per-slot HTML attribute overrides. */
+    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>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputPrefixSlot>;
+    children?: ReactNode;
+}
+type InputPrefixProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, InputPrefixOwnProps>;
+interface InputSuffixOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<InputSuffixSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<InputSuffixSlot>;
+    children?: ReactNode;
+}
+type InputSuffixProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, InputSuffixOwnProps>;
+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>;
+    }
+}
+
+declare const Input: {
+    <T extends react.ElementType = "div">(props: InputProps<T>): react_jsx_runtime.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;
+        displayName: string;
+    };
+    Prefix: {
+        <T extends react.ElementType = "span">(props: InputPrefixProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Suffix: {
+        <T extends react.ElementType = "span">(props: InputSuffixProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+type RadioSize = 'small' | 'base' | 'large';
+type RadioType = 'default' | 'card';
+type RadioPosition = 'left' | 'right';
+type RadioSlot = 'root';
+type RadioItemSlot = 'root';
+type RadioIndicatorSlot = 'root' | 'icon';
+type RadioLabelSlot = 'root';
+/**
+ * Render-prop state surface exposed by `Radio.Item` children.
+ *
+ * This is a callback-parameter shape, not a wrapper prop surface — but the
+ * spar-pick guard matches any `Spar*Props` identifier outside a `Pick<>` so
+ * we list the keys explicitly. Keep them in sync with Spar's
+ * `RadioItemRenderProps`.
+ */
+type RadioRenderProps = Pick<RadioItemRenderProps, 'isChecked' | 'select' | 'disabled' | 'isFocused'>;
+interface RadioOwnProps {
+    /**
+     * Size scale. Cascades to descendant `Radio.Item`s via context.
+     * @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
+     * automatically; a direct prop on `<Radio>` always wins. Maps to Spar's
+     * `invalid` for ARIA wiring (`aria-invalid`).
+     * @defaultValue false
+     */
+    invalid?: boolean;
+    /**
+     * Stretches each item to share the group axis equally. Layout intent only —
+     * styling is recipe-side via `[data-spread] > [data-slot="root"]`.
+     * @defaultValue false
+     */
+    spread?: boolean;
+    /**
+     * Default placement of an item's indicator relative to its label. Cascades
+     * to descendant `Radio.Item`s; per-item `position` overrides the group value.
+     * @defaultValue 'left'
+     */
+    position?: RadioPosition;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<RadioSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<RadioSlot>;
+}
+type RadioProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, RadioOwnProps & Pick<RadioProps$1, 'id' | 'value' | 'defaultValue' | 'onChange' | 'name' | 'disabled' | 'readOnly' | 'required' | 'orientation' | 'selectOnFocus' | 'autoFocus'>>;
+interface RadioItemOwnProps {
+    /**
+     * Override the group-level `position` for this item only.
+     * @defaultValue inherited from group
+     */
+    position?: RadioPosition;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<RadioItemSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<RadioItemSlot>;
+    /** Compound children, or a render function exposing Spar's per-item state. */
+    children?: ReactNode | ((state: RadioRenderProps) => ReactNode);
+}
+type RadioItemProps<T extends ElementType = 'label'> = PolymorphicProps<'label', T, RadioItemOwnProps & Pick<RadioItemProps$1, 'value' | 'disabled'>>;
+interface RadioIndicatorOwnProps {
+    /** Per-slot class name overrides — supports `root` and the internal `icon` slot. */
+    classNames?: ClassNamesMap<RadioIndicatorSlot>;
+    /** Per-slot HTML attribute overrides — supports `root` and the internal `icon` slot. */
+    slotProps?: SlotPropsMap<RadioIndicatorSlot>;
+    /**
+     * Optional custom content for the indicator. When omitted, the wrapper
+     * auto-renders the internal `icon` slot (the default dot). When provided,
+     * the children replace the default slot entirely — useful for swapping in
+     * a check icon or animated marker. The consumer owns checked/unchecked
+     * visibility (typically via the `[data-state="checked"]` ancestor selector
+     * emitted by Spar on `Radio.Item`).
+     */
+    children?: ReactNode;
+}
+type RadioIndicatorProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, RadioIndicatorOwnProps>;
+interface RadioLabelOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<RadioLabelSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<RadioLabelSlot>;
+    children?: ReactNode;
+}
+type RadioLabelProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, RadioLabelOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Radio: ComponentThemeConfig<RadioProps, RadioSlot>;
+        RadioItem: ComponentThemeConfig<RadioItemProps, RadioItemSlot>;
+        RadioIndicator: ComponentThemeConfig<RadioIndicatorProps, RadioIndicatorSlot>;
+        RadioLabel: ComponentThemeConfig<RadioLabelProps, RadioLabelSlot>;
+    }
+}
+
+declare const Radio: {
+    <T extends react.ElementType = "div">(props: RadioProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Item: {
+        <T extends react.ElementType = "label">(props: RadioItemProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Indicator: {
+        <T extends react.ElementType = "span">(props: RadioIndicatorProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Label: {
+        <T extends react.ElementType = "span">(props: RadioLabelProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+/**
+ * Visual variant of the popover content.
+ * @defaultValue 'dark'
+ */
+type PopoverVariant = 'dark' | 'white' | 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+type PopoverTriggerSlot = 'root';
+type PopoverContentSlot = 'root';
+type PopoverHeaderSlot = 'root';
+type PopoverDescriptionSlot = 'root';
+type PopoverArrowSlot = 'root';
+type PopoverCloseSlot = 'root';
+/**
+ * Public props for the Popover root. State-only — renders no DOM, so no
+ * polymorphic `as` and no native HTML props.
+ */
+type PopoverProps = Pick<PopoverProps$1, 'id' | 'open' | 'defaultOpen' | 'onOpenChange' | 'modal' | 'disabled' | 'children'>;
+interface PopoverTriggerOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<PopoverTriggerSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<PopoverTriggerSlot>;
+}
+type PopoverTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, PopoverTriggerOwnProps & Pick<PopoverTriggerProps$1, 'children'>>;
+interface PopoverContentOwnProps {
+    /**
+     * Color variant.
+     * @defaultValue 'dark'
+     */
+    variant?: PopoverVariant;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<PopoverContentSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<PopoverContentSlot>;
+}
+type PopoverContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, PopoverContentOwnProps & Pick<PopoverContentProps$1, 'side' | 'align' | 'container' | 'trapFocus' | 'onOpenAutoFocus' | 'onCloseAutoFocus' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onFocusOutside' | 'onInteractOutside'>>;
+interface PopoverHeaderOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<PopoverHeaderSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<PopoverHeaderSlot>;
+}
+type PopoverHeaderProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, PopoverHeaderOwnProps>;
+interface PopoverDescriptionOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<PopoverDescriptionSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<PopoverDescriptionSlot>;
+}
+type PopoverDescriptionProps<T extends ElementType = 'p'> = PolymorphicProps<'p', T, PopoverDescriptionOwnProps>;
+interface PopoverArrowOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<PopoverArrowSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<PopoverArrowSlot>;
+}
+type PopoverArrowProps<T extends ElementType = 'svg'> = PolymorphicProps<'svg', T, PopoverArrowOwnProps>;
+interface PopoverCloseOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<PopoverCloseSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<PopoverCloseSlot>;
+}
+type PopoverCloseProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, PopoverCloseOwnProps & Pick<PopoverCloseProps$1, 'children'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Popover: StateOnlyComponentThemeConfig<PopoverProps>;
+        PopoverTrigger: ComponentThemeConfig<PopoverTriggerProps, PopoverTriggerSlot>;
+        PopoverContent: ComponentThemeConfig<PopoverContentProps, PopoverContentSlot>;
+        PopoverHeader: ComponentThemeConfig<PopoverHeaderProps, PopoverHeaderSlot>;
+        PopoverDescription: ComponentThemeConfig<PopoverDescriptionProps, PopoverDescriptionSlot>;
+        PopoverArrow: ComponentThemeConfig<PopoverArrowProps, PopoverArrowSlot>;
+        PopoverClose: ComponentThemeConfig<PopoverCloseProps, PopoverCloseSlot>;
+    }
+}
+
+declare const Popover: {
+    (props: PopoverProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Trigger: {
+        <T extends react.ElementType = "button">(props: PopoverTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        <T extends react.ElementType = "div">(props: PopoverContentProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        <T extends react.ElementType = "div">(props: PopoverHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "p">(props: PopoverDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Arrow: {
+        <T extends react.ElementType = "svg">(props: PopoverArrowProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Close: {
+        <T extends react.ElementType = "button">(props: PopoverCloseProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+type SelectSize = 'small' | 'base' | 'large';
+type SelectSlot = 'root';
+type SelectTriggerSlot = 'root';
+type SelectValueSlot = 'root';
+type SelectContentSlot = 'root';
+type SelectItemSlot = 'root';
+type SelectGroupSlot = 'root';
+type SelectLabelSlot = 'root';
+type SelectItemTextSlot = 'root';
+type SelectSeparatorSlot = '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
+ * declare them once on the root.
+ */
+interface SelectOwnProps {
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: SelectSize;
+    /**
+     * Invalid state for form validation styling.
+     * @defaultValue false
+     */
+    invalid?: boolean;
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectSlot>;
+}
+/**
+ * Public props for the Select root. Polymorphic via `as`; ref and the native
+ * attributes of the rendered element are inherited from Spar's
+ * `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'>>;
+interface SelectTriggerOwnProps {
+    /** 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'>>;
+interface SelectValueOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectValueSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectValueSlot>;
+}
+type SelectValueProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, SelectValueOwnProps & Pick<SelectValueProps$1, 'placeholder'>>;
+interface SelectContentOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectContentSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectContentSlot>;
+}
+type SelectContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectContentOwnProps & Pick<SelectContentProps$1, 'side' | 'align' | 'container' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onCloseAutoFocus'>>;
+interface SelectItemOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectItemSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectItemSlot>;
+}
+type SelectItemProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectItemOwnProps & Pick<SelectItemProps$1, 'value' | 'disabled' | 'textValue' | 'children'>>;
+interface SelectGroupOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectGroupSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectGroupSlot>;
+}
+type SelectGroupProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectGroupOwnProps & Pick<SelectGroupProps$1, 'children'>>;
+interface SelectLabelOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectLabelSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectLabelSlot>;
+}
+type SelectLabelProps<T extends ElementType = 'label'> = PolymorphicProps<'label', T, SelectLabelOwnProps & Pick<SelectLabelProps$1, 'children'>>;
+interface SelectItemTextOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectItemTextSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectItemTextSlot>;
+}
+type SelectItemTextProps<T extends ElementType = 'span'> = PolymorphicProps<'span', T, SelectItemTextOwnProps & Pick<SelectItemTextProps$1, 'children'>>;
+interface SelectSeparatorOwnProps {
+    /** Per-slot class name overrides. */
+    classNames?: ClassNamesMap<SelectSeparatorSlot>;
+    /** Per-slot HTML attribute overrides. */
+    slotProps?: SlotPropsMap<SelectSeparatorSlot>;
+}
+type SelectSeparatorProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, SelectSeparatorOwnProps & Pick<SelectSeparatorProps$1, 'children'>>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Select: ComponentThemeConfig<SelectProps, SelectSlot>;
+        SelectTrigger: ComponentThemeConfig<SelectTriggerProps, SelectTriggerSlot>;
+        SelectValue: ComponentThemeConfig<SelectValueProps, SelectValueSlot>;
+        SelectContent: ComponentThemeConfig<SelectContentProps, SelectContentSlot>;
+        SelectItem: ComponentThemeConfig<SelectItemProps, SelectItemSlot>;
+        SelectGroup: ComponentThemeConfig<SelectGroupProps, SelectGroupSlot>;
+        SelectLabel: ComponentThemeConfig<SelectLabelProps, SelectLabelSlot>;
+        SelectItemText: ComponentThemeConfig<SelectItemTextProps, SelectItemTextSlot>;
+        SelectSeparator: ComponentThemeConfig<SelectSeparatorProps, SelectSeparatorSlot>;
+    }
+}
+
+declare const Select: {
+    <T extends react.ElementType = "div">(props: SelectProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Trigger: {
+        <T extends react.ElementType = "button">(props: SelectTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Value: {
+        <T extends react.ElementType = "span">(props: SelectValueProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        <T extends react.ElementType = "div">(props: SelectContentProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Item: {
+        <T extends react.ElementType = "div">(props: SelectItemProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    ItemText: {
+        <T extends react.ElementType = "span">(props: SelectItemTextProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Group: {
+        <T extends react.ElementType = "div">(props: SelectGroupProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Label: {
+        <T extends react.ElementType = "label">(props: SelectLabelProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Separator: {
+        <T extends react.ElementType = "div">(props: SelectSeparatorProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+type SwitchSize = 'xlarge' | 'large' | 'base' | 'small' | 'xsmall';
+type SwitchVariant = 'info' | 'success';
+type SwitchSlot = 'root' | 'indicator' | 'thumb';
+/**
+ * Render props passed to the root `Switch` render-prop child. Re-exports
+ * Spar's shape verbatim — consumers reading the state inside compound
+ * children should use `Switch.Indicator` render-prop instead, which receives
+ * the takeoff-spar split via context.
+ */
+type SwitchRenderProps = SwitchRenderProps$1;
+/**
+ * Render props passed to `Switch.Indicator` function-children. Mirrors the
+ * shape used by `Checkbox.Indicator`.
+ */
+interface SwitchIndicatorRenderProps {
+    checked: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+}
+interface SwitchOwnProps {
+    /**
+     * Size scale.
+     * @defaultValue 'base'
+     */
+    size?: SwitchSize;
+    /**
+     * Color variant used while checked.
+     * @defaultValue 'info'
+     */
+    variant?: SwitchVariant;
+    /**
+     * Marks the switch as visually invalid. When inside a `<Field>`, Spar
+     * inherits the Field's invalid state automatically — pass this prop only
+     * to override.
+     * @defaultValue false
+     */
+    invalid?: boolean;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<SwitchSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<SwitchSlot>;
+    /**
+     * Compound children for the switch anatomy, or a render function exposing
+     * Spar's state. Compound children are the canonical composition path; the
+     * render-prop is preserved for parity with Spar's leaf primitive.
+     */
+    children?: ReactNode | ((state: SwitchRenderProps$1) => ReactNode);
+}
+/**
+ * Public props for `Switch`. Polymorphic via `as` — defaults to Spar's
+ * `<button role="switch">` element.
+ */
+type SwitchProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, SwitchOwnProps & Pick<SwitchProps$1, 'checked' | 'defaultChecked' | 'onChange' | 'disabled' | 'readOnly' | 'required' | 'name' | 'value' | 'form' | 'autoFocus'>>;
+interface SwitchIndicatorProps extends Omit<ComponentPropsWithoutRef<'span'>, 'children'> {
+    /**
+     * Indicator content. When omitted, the built-in track + thumb anatomy is
+     * rendered automatically (a `thumb` slot is mounted inside the indicator
+     * span). When a function, receives the current `checked` / `disabled` /
+     * `readOnly` state from the root and its return value replaces the inner
+     * slot. Passing a `ReactNode` likewise replaces the inner slot entirely —
+     * the consumer becomes responsible for any `data-slot="thumb"` wrapper
+     * they need for theming.
+     */
+    children?: ReactNode | ((state: SwitchIndicatorRenderProps) => ReactNode);
+    ref?: Ref<HTMLSpanElement>;
+}
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        Switch: ComponentThemeConfig<SwitchProps, SwitchSlot>;
+    }
+}
+
+declare const Switch: {
+    <T extends react.ElementType = "button">(props: SwitchProps<T>): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Indicator: {
+        (props: SwitchIndicatorProps): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+};
+
+type TooltipVariant = 'dark' | 'white' | 'info' | 'success' | 'warning' | 'danger' | 'neutral';
+type TooltipTriggerSlot = 'root';
+type TooltipContentSlot = 'root';
+type TooltipHeaderSlot = 'root';
+type TooltipDescriptionSlot = 'root';
+type TooltipArrowSlot = 'root';
+/**
+ * Public props for the Tooltip root. State-only — renders no DOM, so no
+ * polymorphic `as` and no native HTML props.
+ */
+type TooltipProps = Pick<TooltipProps$1, 'id' | 'open' | 'defaultOpen' | 'onOpenChange' | 'delay' | 'hideDelay' | 'disabled' | 'children'>;
+/**
+ * Public props for the Tooltip provider. State-only — renders no DOM.
+ * Shares delay configuration across multiple sibling tooltips so that moving
+ * between them within `skipDelayDuration` opens the next one instantly (WCAG 1.4.13).
+ */
+type TooltipProviderProps = Pick<TooltipProviderProps$1, 'children' | 'delayDuration' | 'skipDelayDuration' | 'disableHoverableContent'>;
+interface TooltipTriggerOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<TooltipTriggerSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<TooltipTriggerSlot>;
+}
+type TooltipTriggerProps<T extends ElementType = 'button'> = PolymorphicProps<'button', T, TooltipTriggerOwnProps & Pick<TooltipTriggerProps$1, 'children'>>;
+interface TooltipContentOwnProps {
+    /**
+     * Color variant.
+     * @defaultValue 'dark'
+     */
+    variant?: TooltipVariant;
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<TooltipContentSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<TooltipContentSlot>;
+}
+type TooltipContentProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, TooltipContentOwnProps & Pick<TooltipContentProps$1, 'side' | 'align' | 'container' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onOpenAutoFocus' | 'onCloseAutoFocus'>>;
+interface TooltipHeaderOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<TooltipHeaderSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<TooltipHeaderSlot>;
+}
+type TooltipHeaderProps<T extends ElementType = 'div'> = PolymorphicProps<'div', T, TooltipHeaderOwnProps>;
+interface TooltipDescriptionOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<TooltipDescriptionSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<TooltipDescriptionSlot>;
+}
+type TooltipDescriptionProps<T extends ElementType = 'p'> = PolymorphicProps<'p', T, TooltipDescriptionOwnProps>;
+interface TooltipArrowOwnProps {
+    /** Per-slot extra classes. */
+    classNames?: ClassNamesMap<TooltipArrowSlot>;
+    /** Per-slot HTML-attribute overrides. */
+    slotProps?: SlotPropsMap<TooltipArrowSlot>;
+}
+type TooltipArrowProps<T extends ElementType = 'svg'> = PolymorphicProps<'svg', T, TooltipArrowOwnProps>;
+declare module '../../core/theme' {
+    interface ComponentThemeRegistry {
+        TooltipTrigger: ComponentThemeConfig<TooltipTriggerProps, TooltipTriggerSlot>;
+        TooltipContent: ComponentThemeConfig<TooltipContentProps, TooltipContentSlot>;
+        TooltipHeader: ComponentThemeConfig<TooltipHeaderProps, TooltipHeaderSlot>;
+        TooltipDescription: ComponentThemeConfig<TooltipDescriptionProps, TooltipDescriptionSlot>;
+        TooltipArrow: ComponentThemeConfig<TooltipArrowProps, TooltipArrowSlot>;
+    }
+}
+
+declare const Tooltip: {
+    ({ children, id, open, defaultOpen, onOpenChange, delay, hideDelay, disabled }: TooltipProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+} & {
+    Provider: {
+        ({ children, delayDuration, skipDelayDuration, disableHoverableContent }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Trigger: {
+        <T extends react.ElementType = "button">(props: TooltipTriggerProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        <T extends react.ElementType = "div">(props: TooltipContentProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Header: {
+        <T extends react.ElementType = "div">(props: TooltipHeaderProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Description: {
+        <T extends react.ElementType = "p">(props: TooltipDescriptionProps<T>): react_jsx_runtime.JSX.Element;
+        displayName: string;
+    };
+    Arrow: {
+        <T extends react.ElementType = "svg">(props: TooltipArrowProps<T>): react_jsx_runtime.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 SelectItemTextProps, type SelectLabelProps, type SelectProps, type SelectSeparatorProps, type SelectSize, type SelectTriggerProps, type SelectValueProps, 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 };