@imfusion/web-ui 0.6.4-dev.8.g41d03f2f → 0.7.0

package/dist/components/slider/slider.d.ts

@@ -1,111 +1,41 @@
 import { Slider as SliderPrimitive } from '@base-ui/react/slider';
-type UpstreamRoot = React.ComponentProps<typeof SliderPrimitive.Root>;
-type UpstreamLabel = React.ComponentProps<typeof SliderPrimitive.Label>;
-type UpstreamValue = React.ComponentProps<typeof SliderPrimitive.Value>;
-type UpstreamControl = React.ComponentProps<typeof SliderPrimitive.Control>;
-type UpstreamTrack = React.ComponentProps<typeof SliderPrimitive.Track>;
-type UpstreamIndicator = React.ComponentProps<typeof SliderPrimitive.Indicator>;
-type UpstreamThumb = React.ComponentProps<typeof SliderPrimitive.Thumb>;
-type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "className" | "style"> & {
-    value?: number | number[];
-    defaultValue?: number | number[];
-    onValueChange?: UpstreamRoot["onValueChange"];
-    onValueCommitted?: UpstreamRoot["onValueCommitted"];
-    min?: number;
-    max?: number;
-    step?: number;
-    largeStep?: number;
-    minStepsBetweenValues?: number;
-    disabled?: boolean;
-    orientation?: "horizontal" | "vertical";
-    name?: string;
-    form?: string;
-    locale?: UpstreamRoot["locale"];
-    thumbAlignment?: UpstreamRoot["thumbAlignment"];
-    thumbCollisionBehavior?: UpstreamRoot["thumbCollisionBehavior"];
-    format?: Intl.NumberFormatOptions;
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
 /**
  * Slider.Root — value selector along a continuous or stepped track.
  *
  * @doc https://base-ui.com/react/components/slider
  * @llm https://base-ui.com/react/components/slider.md
  */
-export declare function Root({ value, defaultValue, onValueChange, onValueCommitted, min, max, step, largeStep, minStepsBetweenValues, disabled, orientation, name, form, locale, thumbAlignment, thumbCollisionBehavior, format, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root({ value, defaultValue, onValueChange, onValueCommitted, min, max, step, largeStep, minStepsBetweenValues, disabled, orientation, name, form, locale, thumbAlignment, thumbCollisionBehavior, format, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type LabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamLabel["className"];
-    style?: UpstreamLabel["style"];
-    render?: UpstreamLabel["render"];
-};
 /** Slider.Label — accessible label for the slider. */
-export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function Label(props: React.ComponentProps<typeof SliderPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Label {
     var displayName: string;
 }
-type ValueProps = Omit<React.HTMLAttributes<HTMLOutputElement>, "children" | "className" | "style"> & {
-    children?: UpstreamValue["children"];
-    className?: UpstreamValue["className"];
-    style?: UpstreamValue["style"];
-    render?: UpstreamValue["render"];
-};
 /** Slider.Value — live numeric readout. */
-export declare function Value({ className, children, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+export declare function Value({ children, ...props }: React.ComponentProps<typeof SliderPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Value {
     var displayName: string;
 }
-type ControlProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamControl["className"];
-    style?: UpstreamControl["style"];
-    render?: UpstreamControl["render"];
-};
 /** Slider.Control — interactive container for track + thumb. */
-export declare function Control({ className, ...props }: ControlProps): import("react/jsx-runtime").JSX.Element;
+export declare function Control(props: React.ComponentProps<typeof SliderPrimitive.Control>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Control {
     var displayName: string;
 }
-type TrackProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamTrack["className"];
-    style?: UpstreamTrack["style"];
-    render?: UpstreamTrack["render"];
-};
 /** Slider.Track — the static rail. */
-export declare function Track({ className, ...props }: TrackProps): import("react/jsx-runtime").JSX.Element;
+export declare function Track(props: React.ComponentProps<typeof SliderPrimitive.Track>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Track {
     var displayName: string;
 }
-type IndicatorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamIndicator["className"];
-    style?: UpstreamIndicator["style"];
-    render?: UpstreamIndicator["render"];
-};
 /** Slider.Indicator — filled portion of the track. */
-export declare function Indicator({ className, ...props }: IndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function Indicator(props: React.ComponentProps<typeof SliderPrimitive.Indicator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Indicator {
     var displayName: string;
 }
-type ThumbProps = Omit<React.HTMLAttributes<HTMLDivElement>, "onBlur" | "onFocus" | "className" | "style"> & {
-    index?: number;
-    tabIndex?: number;
-    /** @default false */
-    disabled?: boolean;
-    inputRef?: React.Ref<HTMLInputElement>;
-    getAriaLabel?: UpstreamThumb["getAriaLabel"];
-    getAriaValueText?: UpstreamThumb["getAriaValueText"];
-    onBlur?: UpstreamThumb["onBlur"];
-    onFocus?: UpstreamThumb["onFocus"];
-    className?: UpstreamThumb["className"];
-    style?: UpstreamThumb["style"];
-    render?: UpstreamThumb["render"];
-};
 /** Slider.Thumb — draggable handle. */
-export declare function Thumb({ index, className, ...props }: ThumbProps): import("react/jsx-runtime").JSX.Element;
+export declare function Thumb({ index, ...props }: React.ComponentProps<typeof SliderPrimitive.Thumb>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Thumb {
     var displayName: string;
 }
-export {};

package/dist/components/spinner/spinner.d.ts

@@ -1,19 +1,24 @@
 import { VariantProps } from 'class-variance-authority';
+declare const sources: {
+    blue: string;
+    white: string;
+    black: string;
+};
 declare const spinner: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 type Props = Omit<React.HTMLAttributes<HTMLSpanElement>, "role"> & VariantProps<typeof spinner> & {
     /** Accessible label announced by assistive tech. */
     label?: string;
+    /**
+     * Which colour of the mark to show. The animation is a pre-rendered image, so
+     * the colour is baked in and does not follow `currentColor` or the scheme —
+     * pick `white` on saturated or dark grounds.
+     */
+    variant?: keyof typeof sources;
 };
 /**
- * Loading indicator built from the animated ImFusion glyph — two filled bands
- * and an empty diagonal channel that continuously rotates, breathes, and sways.
- *
- * The motion is a live per-frame morph of the two paths (the channel geometry is
- * recomputed each frame in {@link frameGeometry}), driven by a single
- * `requestAnimationFrame` loop that rewrites the two `d` attributes directly —
- * no React re-render per frame. The loop pauses while the tab is hidden.
+ * Loading indicator — the ImFusion glyph animation, played as a looping image.
  */
-export declare function Spinner({ size, label, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Spinner({ size, variant, label, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/stack/stack.d.ts

@@ -8,11 +8,10 @@ type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof stack>;
 /**
  * Stack — vertical layout primitive.
  *
- * Copied and adapted from Mantine's Stack; no upstream runtime
- * dependency. Pure column flex container with token-driven gap and constrained
- * align/justify unions.
+ * Adapted from Mantine's Stack, no upstream runtime dependency: a pure column
+ * flex container with token-driven gap and constrained align/justify unions.
  *
  * @see https://mantine.dev/core/stack/
  */
-export declare function Stack({ gap, align, justify, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Stack({ gap, align, justify, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/switch/switch.d.ts

@@ -1,45 +1,16 @@
 import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
-type UpstreamRoot = React.ComponentProps<typeof SwitchPrimitive.Root>;
-type UpstreamThumb = React.ComponentProps<typeof SwitchPrimitive.Thumb>;
-type RootProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    checked?: boolean;
-    defaultChecked?: boolean;
-    onCheckedChange?: UpstreamRoot["onCheckedChange"];
-    /** @default false */
-    disabled?: boolean;
-    /** @default false */
-    readOnly?: boolean;
-    /** @default false */
-    required?: boolean;
-    name?: string;
-    value?: string;
-    uncheckedValue?: string;
-    form?: string;
-    inputRef?: React.Ref<HTMLInputElement>;
-    /** @default false */
-    nativeButton?: boolean;
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
 /**
  * Switch.Root — toggleable on/off control.
  *
  * @doc https://base-ui.com/react/components/switch
  * @llm https://base-ui.com/react/components/switch.md
  */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root(props: React.ComponentProps<typeof SwitchPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type ThumbProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    className?: UpstreamThumb["className"];
-    style?: UpstreamThumb["style"];
-    render?: UpstreamThumb["render"];
-};
 /** Switch.Thumb — the movable indicator inside the track. */
-export declare function Thumb({ className, ...props }: ThumbProps): import("react/jsx-runtime").JSX.Element;
+export declare function Thumb(props: React.ComponentProps<typeof SwitchPrimitive.Thumb>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Thumb {
     var displayName: string;
 }
-export {};

package/dist/components/table/table.d.ts

@@ -1,37 +1,31 @@
-type RootProps = React.TableHTMLAttributes<HTMLTableElement>;
-type HeaderProps = React.HTMLAttributes<HTMLTableSectionElement>;
-type BodyProps = React.HTMLAttributes<HTMLTableSectionElement>;
-type RowProps = React.HTMLAttributes<HTMLTableRowElement>;
 type HeaderCellProps = React.ThHTMLAttributes<HTMLTableCellElement>;
-type CellProps = React.TdHTMLAttributes<HTMLTableCellElement>;
-type HeaderButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
 /** Table.Root — the `<table>` element. */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root(props: React.TableHTMLAttributes<HTMLTableElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
 /** Table.Header — the `<thead>` section. */
-export declare function Header({ className, ...props }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function Header(props: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Header {
     var displayName: string;
 }
 /** Table.Body — the `<tbody>` section. */
-export declare function Body({ className, ...props }: BodyProps): import("react/jsx-runtime").JSX.Element;
+export declare function Body(props: React.HTMLAttributes<HTMLTableSectionElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Body {
     var displayName: string;
 }
 /** Table.Row — a `<tr>` in header or body. */
-export declare function Row({ className, ...props }: RowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Row(props: React.HTMLAttributes<HTMLTableRowElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Row {
     var displayName: string;
 }
 /** Table.HeaderCell — a `<th>` header cell. */
-export declare function HeaderCell({ className, ...props }: HeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export declare function HeaderCell(props: HeaderCellProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace HeaderCell {
     var displayName: string;
 }
 /** Table.Cell — a `<td>` data cell. */
-export declare function Cell({ className, ...props }: CellProps): import("react/jsx-runtime").JSX.Element;
+export declare function Cell(props: React.TdHTMLAttributes<HTMLTableCellElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Cell {
     var displayName: string;
 }
@@ -40,7 +34,7 @@ export declare namespace Cell {
  * design: sorting toggles, filter toggles, column menus all render through it
  * rather than each inventing a button. Icon/indicator goes in `children`.
  */
-export declare function HeaderButton({ className, type, ...props }: HeaderButtonProps): import("react/jsx-runtime").JSX.Element;
+export declare function HeaderButton({ type, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace HeaderButton {
     var displayName: string;
 }
@@ -53,11 +47,9 @@ type SortableHeaderCellProps = Omit<HeaderCellProps, "aria-sort"> & {
     onToggle?: React.MouseEventHandler<HTMLButtonElement>;
 };
 /**
- * Table.SortableHeaderCell — a partial: a header cell whose label is a sort
- * toggle, pre-composing HeaderCell + HeaderButton so the `aria-sort` state and
- * direction indicator don't get re-derived per consumer app. Headless-upstream-
- * agnostic: feed it `sortDirection` and `onToggle` (e.g. from a TanStack
- * column). Omit `onToggle` and it renders a plain non-sortable header cell.
+ * Table.SortableHeaderCell — a header cell whose label is a sort toggle,
+ * pre-composing HeaderCell + HeaderButton so `aria-sort` and the direction
+ * indicator aren't re-derived per consumer. Omit `onToggle` for a plain cell.
  */
 export declare function SortableHeaderCell({ sortDirection, onToggle, children, ...props }: SortableHeaderCellProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace SortableHeaderCell {

package/dist/components/tabs/tabs.d.ts

@@ -1,90 +1,56 @@
 import { Tabs as TabsPrimitive } from '@base-ui/react/tabs';
-type UpstreamRoot = React.ComponentProps<typeof TabsPrimitive.Root>;
-type UpstreamList = React.ComponentProps<typeof TabsPrimitive.List>;
-type UpstreamTab = React.ComponentProps<typeof TabsPrimitive.Tab>;
-type UpstreamIndicator = React.ComponentProps<typeof TabsPrimitive.Indicator>;
-type UpstreamPanel = React.ComponentProps<typeof TabsPrimitive.Panel>;
-type RootProps = UpstreamRoot;
+import { VariantProps } from 'class-variance-authority';
+declare const tabsList: (props?: ({
+    fill?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
 /**
  * Tabs.Root — container that manages the active tab value and orientation context.
  *
  * @see https://base-ui.com/react/components/tabs
  * @llm https://base-ui.com/react/components/tabs.md
  */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root(props: React.ComponentProps<typeof TabsPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type ListProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    /** @default false */
-    activateOnFocus?: UpstreamList["activateOnFocus"];
-    /** @default true */
-    loopFocus?: UpstreamList["loopFocus"];
+interface ListProps extends React.ComponentProps<typeof TabsPrimitive.List>, VariantProps<typeof tabsList> {
     /**
      * Give every tab an equal share of the list's length (equal width when
      * horizontal). When vertical, this only takes effect if the list is stretched
      * to a definite height.
-     * @default false
      */
-    fill?: boolean;
-    className?: UpstreamList["className"];
-    render?: UpstreamList["render"];
-};
+    fill?: VariantProps<typeof tabsList>["fill"];
+}
 /** Tabs.List — the strip of Tabs.Tab triggers, plus the sliding Tabs.Indicator. */
-export declare function List({ fill, className, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
+export declare function List({ fill, ref, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace List {
     var displayName: string;
 }
-type TabProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "value" | "disabled"> & {
-    value: UpstreamTab["value"];
-    /** @default true */
-    nativeButton?: UpstreamTab["nativeButton"];
-    disabled?: UpstreamTab["disabled"];
-    className?: UpstreamTab["className"];
-    render?: UpstreamTab["render"];
-};
 /** Tabs.Tab — a single trigger. Reads `data-active`/`data-disabled` from Base UI for all visual state. */
-export declare function Tab({ className, ...props }: TabProps): import("react/jsx-runtime").JSX.Element;
+export declare function Tab(props: React.ComponentProps<typeof TabsPrimitive.Tab>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Tab {
     var displayName: string;
 }
-type IndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className"> & {
-    /** @default false */
-    renderBeforeHydration?: UpstreamIndicator["renderBeforeHydration"];
-    className?: UpstreamIndicator["className"];
-    render?: UpstreamIndicator["render"];
-};
 /**
- * Tabs.Indicator — the bordered box marking the active tab, overlapping the
- * shared hairline border to visually fuse the active tab with the panel
- * frame beneath it. Positioned via the `--active-tab-*` CSS custom
- * properties Base UI writes onto it; render once per Tabs.List, after the
- * Tabs.Tab list.
+ * Tabs.Indicator — the bordered box marking the active tab, positioned via
+ * the `--active-tab-*` CSS custom properties Base UI writes onto it. Render
+ * once per Tabs.List, after the Tabs.Tab list.
  */
-export declare function Indicator({ className, ...props }: IndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function Indicator(props: React.ComponentProps<typeof TabsPrimitive.Indicator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Indicator {
     var displayName: string;
 }
-type PanelViewportProps = React.HTMLAttributes<HTMLDivElement>;
 /**
  * Tabs.PanelViewport — the shared frame Tabs.Panel elements render inside.
- * No Base UI equivalent exists (upstream leaves this as a plain wrapper div
- * in its own reference); we surface it as a named part since its hairline
- * border is what Tabs.Indicator visually fuses into.
+ * No Base UI equivalent exists; it's surfaced as a named part since its
+ * hairline border is what Tabs.Indicator visually fuses into.
  */
-export declare function PanelViewport({ className, ...props }: PanelViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare function PanelViewport(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace PanelViewport {
     var displayName: string;
 }
-type PanelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    value: UpstreamPanel["value"];
-    /** @default false */
-    keepMounted?: UpstreamPanel["keepMounted"];
-    className?: UpstreamPanel["className"];
-    render?: UpstreamPanel["render"];
-};
 /** Tabs.Panel — the content shown for a matching Tabs.Tab value. */
-export declare function Panel({ className, ...props }: PanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function Panel(props: React.ComponentProps<typeof TabsPrimitive.Panel>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Panel {
     var displayName: string;
 }

package/dist/components/toast/toast.d.ts

@@ -1,19 +1,8 @@
 import { Toast as ToastPrimitive } from '@base-ui/react/toast';
 import { VariantProps } from 'class-variance-authority';
-type UpstreamProvider = React.ComponentProps<typeof ToastPrimitive.Provider>;
-type UpstreamPortal = React.ComponentProps<typeof ToastPrimitive.Portal>;
-type UpstreamViewport = React.ComponentProps<typeof ToastPrimitive.Viewport>;
-type UpstreamRoot = React.ComponentProps<typeof ToastPrimitive.Root>;
-type UpstreamContent = React.ComponentProps<typeof ToastPrimitive.Content>;
-type UpstreamTitle = React.ComponentProps<typeof ToastPrimitive.Title>;
-type UpstreamDescription = React.ComponentProps<typeof ToastPrimitive.Description>;
-type UpstreamClose = React.ComponentProps<typeof ToastPrimitive.Close>;
-type UpstreamAction = React.ComponentProps<typeof ToastPrimitive.Action>;
-type UpstreamPositioner = React.ComponentProps<typeof ToastPrimitive.Positioner>;
-type UpstreamArrow = React.ComponentProps<typeof ToastPrimitive.Arrow>;
 declare const toastViewport: (props?: ({
     position?: "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | null | undefined;
-    width?: "content" | "default" | "compact" | "wide" | null | undefined;
+    width?: "default" | "content" | "compact" | "wide" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare const toastRoot: (props?: ({
     variant?: "warning" | "info" | "neutral" | "success" | "error" | null | undefined;
@@ -30,12 +19,6 @@ export declare const useToastManager: typeof ToastPrimitive.useToastManager;
  * `toastManager`.
  */
 export declare const createToastManager: typeof ToastPrimitive.createToastManager;
-type ProviderProps = {
-    timeout?: UpstreamProvider["timeout"];
-    limit?: UpstreamProvider["limit"];
-    toastManager?: UpstreamProvider["toastManager"];
-    children?: UpstreamProvider["children"];
-};
 /**
  * Toast.Provider — owns the toast queue for its subtree. Renders no DOM element.
  *
@@ -45,155 +28,85 @@ type ProviderProps = {
  * @see https://base-ui.com/react/components/toast
  * @llm https://base-ui.com/react/components/toast.md
  */
-export declare function Provider({ timeout, limit, ...props }: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function Provider({ timeout, limit, ...props }: React.ComponentProps<typeof ToastPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Provider {
     var displayName: string;
 }
-type PortalProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    container?: UpstreamPortal["container"];
-    className?: UpstreamPortal["className"];
-    render?: UpstreamPortal["render"];
-    children?: UpstreamPortal["children"];
-};
 /** Toast.Portal — moves the viewport out of the page flow so toasts float above the app. */
-export declare function Portal({ className, ...props }: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare function Portal(props: React.ComponentProps<typeof ToastPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Portal {
     var displayName: string;
 }
-type ViewportProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+interface ViewportProps extends React.ComponentProps<typeof ToastPrimitive.Viewport>, VariantProps<typeof toastViewport> {
     /** Which edge or corner of the screen the stack anchors to. */
     position?: VariantProps<typeof toastViewport>["position"];
     /** Width treatment for the toast stack. */
     width?: VariantProps<typeof toastViewport>["width"];
-    className?: UpstreamViewport["className"];
-    render?: UpstreamViewport["render"];
-};
+}
 /**
  * Toast.Viewport — the fixed layer that holds the stack. Hovering or focusing it
  * expands the collapsed toasts; it ignores pointer events except on the toasts
  * themselves so the app underneath stays clickable.
  */
-export declare function Viewport({ className, position, width, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare function Viewport({ position, width, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Viewport {
     var displayName: string;
 }
-type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+interface RootProps extends React.ComponentProps<typeof ToastPrimitive.Root>, VariantProps<typeof toastRoot> {
     /** Semantic treatment for the toast surface. */
     variant?: VariantProps<typeof toastRoot>["variant"];
-    /** The toast object from the manager's `toasts` array. */
-    toast: UpstreamRoot["toast"];
-    /** @default ['down', 'right'] */
-    swipeDirection?: UpstreamRoot["swipeDirection"];
-    className?: UpstreamRoot["className"];
-    render?: UpstreamRoot["render"];
-};
+}
 /**
  * Toast.Root — one toast surface. Carries the upstream state as data attributes
  * (`data-starting-style`, `data-ending-style`, `data-expanded`, `data-limited`,
  * `data-swiping`) which the stylesheet uses for stack and exit motion.
  */
-export declare function Root({ className, variant, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root({ variant, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type ContentProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    className?: UpstreamContent["className"];
-    render?: UpstreamContent["render"];
-};
 /**
  * Toast.Content — lays out title, description, action, and close. Fades out on
  * the toasts stacked behind the frontmost one via `data-behind`.
  */
-export declare function Content({ className, ...props }: ContentProps): import("react/jsx-runtime").JSX.Element;
+export declare function Content(props: React.ComponentProps<typeof ToastPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Content {
     var displayName: string;
 }
-type TitleProps = Omit<React.HTMLAttributes<HTMLHeadingElement>, "className"> & {
-    className?: UpstreamTitle["className"];
-    render?: UpstreamTitle["render"];
-};
 /** Toast.Title — the message heading. Falls back to the toast object's `title` when given no children. */
-export declare function Title({ className, ...props }: TitleProps): import("react/jsx-runtime").JSX.Element;
+export declare function Title(props: React.ComponentProps<typeof ToastPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Title {
     var displayName: string;
 }
-type DescriptionProps = Omit<React.HTMLAttributes<HTMLParagraphElement>, "className"> & {
-    className?: UpstreamDescription["className"];
-    render?: UpstreamDescription["render"];
-};
 /** Toast.Description — supporting copy. Falls back to the toast object's `description` when given no children. */
-export declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare function Description(props: React.ComponentProps<typeof ToastPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Description {
     var displayName: string;
 }
-type CloseProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
-    /** @default true */
-    nativeButton?: UpstreamClose["nativeButton"];
-    className?: UpstreamClose["className"];
-    render?: UpstreamClose["render"];
-};
 /** Toast.Close — dismisses the toast it sits in. */
-export declare function Close({ className, ...props }: CloseProps): import("react/jsx-runtime").JSX.Element;
+export declare function Close(props: React.ComponentProps<typeof ToastPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Close {
     var displayName: string;
 }
-type ActionProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
-    /** @default true */
-    nativeButton?: UpstreamAction["nativeButton"];
-    className?: UpstreamAction["className"];
-    render?: UpstreamAction["render"];
-};
 /**
  * Toast.Action — the toast's single affordance, typically an undo. Its behavior
  * comes from `actionProps` on the toast object passed to the manager.
  */
-export declare function Action({ className, ...props }: ActionProps): import("react/jsx-runtime").JSX.Element;
+export declare function Action(props: React.ComponentProps<typeof ToastPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Action {
     var displayName: string;
 }
-type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    /** The toast object from the manager's `toasts` array. */
-    toast: UpstreamPositioner["toast"];
-    /** @default 'top' */
-    side?: UpstreamPositioner["side"];
-    /** @default 'center' */
-    align?: UpstreamPositioner["align"];
-    /** @default 0 */
-    sideOffset?: UpstreamPositioner["sideOffset"];
-    /** @default 0 */
-    alignOffset?: UpstreamPositioner["alignOffset"];
-    /** @default 5 */
-    arrowPadding?: UpstreamPositioner["arrowPadding"];
-    anchor?: UpstreamPositioner["anchor"];
-    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
-    /** @default 'clipping-ancestors' */
-    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
-    /** @default 5 */
-    collisionPadding?: UpstreamPositioner["collisionPadding"];
-    /** @default 'absolute' */
-    positionMethod?: UpstreamPositioner["positionMethod"];
-    /** @default false */
-    sticky?: UpstreamPositioner["sticky"];
-    /** @default false */
-    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
-    className?: UpstreamPositioner["className"];
-    render?: UpstreamPositioner["render"];
-};
 /**
  * Toast.Positioner — anchors a toast to an element instead of the stack, for
  * feedback that belongs next to the control that caused it. Wrap a `Root` in it
  * and the root switches to the compact content-sized surface.
  */
-export declare function Positioner({ className, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Positioner(props: React.ComponentProps<typeof ToastPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Positioner {
     var displayName: string;
 }
-type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    className?: UpstreamArrow["className"];
-    render?: UpstreamArrow["render"];
-};
 /** Toast.Arrow — pointer joining an anchored toast to its anchor. Receives `data-side` for orientation. */
-export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Arrow(props: React.ComponentProps<typeof ToastPrimitive.Arrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Arrow {
     var displayName: string;
 }

package/dist/components/toggle/toggle.d.ts

@@ -1,24 +1,6 @@
 import { Toggle as TogglePrimitive } from '@base-ui/react/toggle';
-type UpstreamToggle = React.ComponentProps<typeof TogglePrimitive>;
-type Props = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style" | "value" | "disabled"> & {
-    /**
-     * Identifies the toggle within a `ToggleGroup`: the value contributed to the
-     * group's value array. Optional for a standalone toggle.
-     */
-    value?: UpstreamToggle["value"];
-    /** Whether the toggle is pressed. */
-    pressed?: UpstreamToggle["pressed"];
-    /** @default false */
-    defaultPressed?: UpstreamToggle["defaultPressed"];
-    onPressedChange?: UpstreamToggle["onPressedChange"];
-    /** @default false */
-    disabled?: UpstreamToggle["disabled"];
-    /** @default true */
-    nativeButton?: UpstreamToggle["nativeButton"];
-    className?: UpstreamToggle["className"];
-    style?: UpstreamToggle["style"];
-    render?: UpstreamToggle["render"];
-};
+interface Props extends React.ComponentProps<typeof TogglePrimitive> {
+}
 /**
  * Toggle - a two-state button. Use standalone for a
  * single on/off action (bold, mute), or compose several inside a `ToggleGroup`
@@ -27,5 +9,5 @@ type Props = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "
  * @doc https://base-ui.com/react/components/toggle
  * @llm https://base-ui.com/react/components/toggle.md
  */
-export declare function Toggle({ className, style, children, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Toggle({ style, children, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};