@imfusion/web-ui 0.6.4-dev.29.g527b8ff6 → 0.6.4-dev.31.gcef47041

package/dist/components/popover/popover.d.ts

@@ -1,14 +1,15 @@
 import { Popover as PopoverPrimitive } from '@base-ui/react/popover';
+import { VariantProps } from 'class-variance-authority';
 type UpstreamTrigger = React.ComponentProps<typeof PopoverPrimitive.Trigger>;
-type UpstreamPortal = React.ComponentProps<typeof PopoverPrimitive.Portal>;
-type UpstreamBackdrop = React.ComponentProps<typeof PopoverPrimitive.Backdrop>;
 type UpstreamPositioner = React.ComponentProps<typeof PopoverPrimitive.Positioner>;
 type UpstreamPopup = React.ComponentProps<typeof PopoverPrimitive.Popup>;
-type UpstreamArrow = React.ComponentProps<typeof PopoverPrimitive.Arrow>;
-type UpstreamViewport = React.ComponentProps<typeof PopoverPrimitive.Viewport>;
-type UpstreamTitle = React.ComponentProps<typeof PopoverPrimitive.Title>;
-type UpstreamDescription = React.ComponentProps<typeof PopoverPrimitive.Description>;
-type UpstreamClose = React.ComponentProps<typeof PopoverPrimitive.Close>;
+declare const popoverTrigger: (props?: ({
+    variant?: "primary" | "secondary" | "positive" | "negative" | "outline" | "ghost" | null | undefined;
+    inline?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const popoverPopup: (props?: ({
+    variant?: "primary" | "secondary" | "positive" | "negative" | "outline" | "ghost" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export declare const createHandle: typeof PopoverPrimitive.createHandle;
 type RootProps<Payload = unknown> = React.ComponentProps<typeof PopoverPrimitive.Root<Payload>>;
 /**
@@ -21,135 +22,62 @@ export declare function Root<Payload = unknown>(props: RootProps<Payload>): impo
 export declare namespace Root {
     var displayName: string;
 }
-type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className"> & {
-    variant?: "ghost" | "outline" | "primary" | "secondary" | "positive" | "negative";
-    inline?: boolean;
-    /** @default true */
-    nativeButton?: UpstreamTrigger["nativeButton"];
-    /** @default false */
-    openOnHover?: UpstreamTrigger["openOnHover"];
-    /** @default 300 */
-    delay?: UpstreamTrigger["delay"];
-    /** @default 0 */
-    closeDelay?: UpstreamTrigger["closeDelay"];
-    handle?: UpstreamTrigger["handle"];
-    payload?: UpstreamTrigger["payload"];
-    className?: UpstreamTrigger["className"];
-    render?: UpstreamTrigger["render"];
-};
 /** Popover.Trigger — button that opens the popover. */
-export declare function Trigger({ variant, inline, className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Trigger({ variant, inline, ...props }: UpstreamTrigger & VariantProps<typeof popoverTrigger>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Trigger {
     var displayName: string;
 }
-type PortalProps = {
-    container?: UpstreamPortal["container"];
-    /** @default false */
-    keepMounted?: UpstreamPortal["keepMounted"];
-    children?: UpstreamPortal["children"];
-};
 /** Popover.Portal — renders the positioner in a portal outside the main document flow. */
-export declare function Portal(props: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare function Portal(props: React.ComponentProps<typeof PopoverPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Portal {
     var displayName: string;
 }
-type BackdropProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    className?: UpstreamBackdrop["className"];
-    render?: UpstreamBackdrop["render"];
-};
 /** Popover.Backdrop — overlay beneath the popover. Receives data-open/data-closed for transitions. */
-export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare function Backdrop(props: React.ComponentProps<typeof PopoverPrimitive.Backdrop>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Backdrop {
     var displayName: string;
 }
-type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    /** @default 'bottom' */
-    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"];
-    /** @default false */
-    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
-    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
-    /** @default 'clipping-ancestors' */
-    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
-    /** @default 5 */
-    collisionPadding?: UpstreamPositioner["collisionPadding"];
-    /** @default false */
-    sticky?: UpstreamPositioner["sticky"];
-    className?: UpstreamPositioner["className"];
-    render?: UpstreamPositioner["render"];
-};
 /** Popover.Positioner — positions the popup relative to the trigger via floating-point layout. */
-export declare function Positioner({ className, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Positioner(props: React.ComponentProps<typeof PopoverPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Positioner {
     var displayName: string;
 }
-type PopupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
+interface PopupProps extends UpstreamPopup, VariantProps<typeof popoverPopup> {
     /** Match to the Trigger variant to tint the popup border accordingly. */
-    variant?: "ghost" | "outline" | "primary" | "secondary" | "positive" | "negative";
-    className?: UpstreamPopup["className"];
-    render?: UpstreamPopup["render"];
-};
+    variant?: VariantProps<typeof popoverPopup>["variant"];
+}
 /** Popover.Popup — the visible surface of the popover. Token-mapped background, border, and shadow. */
-export declare function Popup({ className, variant, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Popup({ variant, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Popup {
     var displayName: string;
 }
-type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    className?: UpstreamArrow["className"];
-    render?: UpstreamArrow["render"];
-};
 /** Popover.Arrow — visual pointer arrow anchored to the popup edge. 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 PopoverPrimitive.Arrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Arrow {
     var displayName: string;
 }
-type ViewportProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    className?: UpstreamViewport["className"];
-    render?: UpstreamViewport["render"];
-};
 /** Popover.Viewport — content wrapper that supports direction-aware animations. */
-export declare function Viewport({ className, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare function Viewport(props: React.ComponentProps<typeof PopoverPrimitive.Viewport>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Viewport {
     var displayName: string;
 }
-type EyebrowProps = React.HTMLAttributes<HTMLParagraphElement>;
 /** Popover.Eyebrow — small uppercase label above Title, for a category or kicker (e.g. "Glossary definition"). */
-export declare function Eyebrow({ className, ...props }: EyebrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Eyebrow(props: React.HTMLAttributes<HTMLParagraphElement>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Eyebrow {
     var displayName: string;
 }
-type TitleProps = React.HTMLAttributes<HTMLHeadingElement> & {
-    render?: UpstreamTitle["render"];
-};
 /** Popover.Title — semantic heading for the popover's accessible name. */
-export declare function Title({ className, ...props }: TitleProps): import("react/jsx-runtime").JSX.Element;
+export declare function Title(props: React.ComponentProps<typeof PopoverPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Title {
     var displayName: string;
 }
-type DescriptionProps = React.HTMLAttributes<HTMLParagraphElement> & {
-    render?: UpstreamDescription["render"];
-};
 /** Popover.Description — supplementary paragraph for the popover's accessible description. */
-export declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
+export declare function Description(props: React.ComponentProps<typeof PopoverPrimitive.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"];
-};
 /** Popover.Close — button that dismisses the popover. */
-export declare function Close({ className, ...props }: CloseProps): import("react/jsx-runtime").JSX.Element;
+export declare function Close(props: React.ComponentProps<typeof PopoverPrimitive.Close>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Close {
     var displayName: string;
 }

package/dist/components/row/row.d.ts

@@ -24,5 +24,5 @@ type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof row> & {
  *
  * @see https://mantine.dev/core/group/
  */
-export declare function Row({ gap, align, justify, wrap, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Row({ gap, align, justify, wrap, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/select/select.d.ts

@@ -1,56 +1,8 @@
 import { Select as SelectPrimitive } from '@base-ui/react/select';
 type UpstreamRoot<Value = unknown, Multiple extends boolean | undefined = false> = React.ComponentProps<typeof SelectPrimitive.Root<Value, Multiple>>;
-type UpstreamLabel = React.ComponentProps<typeof SelectPrimitive.Label>;
-type UpstreamTrigger = React.ComponentProps<typeof SelectPrimitive.Trigger>;
-type UpstreamValue = React.ComponentProps<typeof SelectPrimitive.Value>;
-type UpstreamIcon = React.ComponentProps<typeof SelectPrimitive.Icon>;
-type UpstreamPortal = React.ComponentProps<typeof SelectPrimitive.Portal>;
-type UpstreamBackdrop = React.ComponentProps<typeof SelectPrimitive.Backdrop>;
-type UpstreamPositioner = React.ComponentProps<typeof SelectPrimitive.Positioner>;
-type UpstreamPopup = React.ComponentProps<typeof SelectPrimitive.Popup>;
-type UpstreamArrow = React.ComponentProps<typeof SelectPrimitive.Arrow>;
-type UpstreamList = React.ComponentProps<typeof SelectPrimitive.List>;
 type UpstreamItem = React.ComponentProps<typeof SelectPrimitive.Item>;
-type UpstreamItemIndicator = React.ComponentProps<typeof SelectPrimitive.ItemIndicator>;
-type UpstreamItemText = React.ComponentProps<typeof SelectPrimitive.ItemText>;
-type UpstreamGroup = React.ComponentProps<typeof SelectPrimitive.Group>;
-type UpstreamGroupLabel = React.ComponentProps<typeof SelectPrimitive.GroupLabel>;
-type UpstreamSeparator = React.ComponentProps<typeof SelectPrimitive.Separator>;
-type UpstreamScrollUpArrow = React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>;
-type UpstreamScrollDownArrow = React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>;
-type RootProps<Value = unknown, Multiple extends boolean | undefined = false> = {
-    value?: UpstreamRoot<Value, Multiple>["value"];
-    defaultValue?: UpstreamRoot<Value, Multiple>["defaultValue"];
-    onValueChange?: UpstreamRoot<Value, Multiple>["onValueChange"];
-    /** @default false */
-    defaultOpen?: UpstreamRoot<Value, Multiple>["defaultOpen"];
-    open?: UpstreamRoot<Value, Multiple>["open"];
-    onOpenChange?: UpstreamRoot<Value, Multiple>["onOpenChange"];
-    onOpenChangeComplete?: UpstreamRoot<Value, Multiple>["onOpenChangeComplete"];
-    /** @default false */
-    multiple?: UpstreamRoot<Value, Multiple>["multiple"];
-    /** @default false */
-    disabled?: UpstreamRoot<Value, Multiple>["disabled"];
-    /** @default false */
-    readOnly?: UpstreamRoot<Value, Multiple>["readOnly"];
-    /** @default false */
-    required?: UpstreamRoot<Value, Multiple>["required"];
-    /** @default true */
-    modal?: UpstreamRoot<Value, Multiple>["modal"];
-    /** @default true */
-    highlightItemOnHover?: UpstreamRoot<Value, Multiple>["highlightItemOnHover"];
-    items?: UpstreamRoot<Value, Multiple>["items"];
-    isItemEqualToValue?: UpstreamRoot<Value, Multiple>["isItemEqualToValue"];
-    itemToStringLabel?: UpstreamRoot<Value, Multiple>["itemToStringLabel"];
-    itemToStringValue?: UpstreamRoot<Value, Multiple>["itemToStringValue"];
-    autoComplete?: UpstreamRoot<Value, Multiple>["autoComplete"];
-    form?: UpstreamRoot<Value, Multiple>["form"];
-    inputRef?: UpstreamRoot<Value, Multiple>["inputRef"];
-    actionsRef?: UpstreamRoot<Value, Multiple>["actionsRef"];
-    name?: UpstreamRoot<Value, Multiple>["name"];
-    id?: UpstreamRoot<Value, Multiple>["id"];
-    children?: React.ReactNode;
-};
+interface RootProps<Value = unknown, Multiple extends boolean | undefined = false> extends UpstreamRoot<Value, Multiple> {
+}
 /**
  * Select.Root — accessible select / listbox primitive.
  *
@@ -68,210 +20,96 @@ export declare function Root<Value = unknown, Multiple extends boolean | undefin
 export declare namespace Root {
     var displayName: string;
 }
-type LabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamLabel["className"];
-    style?: UpstreamLabel["style"];
-    render?: UpstreamLabel["render"];
-};
 /** Select.Label — visible label for the trigger. */
-export declare function Label({ className, ...props }: LabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function Label(props: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Label {
     var displayName: string;
 }
-type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style"> & {
-    /** @default true */
-    nativeButton?: UpstreamTrigger["nativeButton"];
-    className?: UpstreamTrigger["className"];
-    style?: UpstreamTrigger["style"];
-    render?: UpstreamTrigger["render"];
-};
 /** Select.Trigger — button that opens the popup. */
-export declare function Trigger({ className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Trigger(props: React.ComponentProps<typeof SelectPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Trigger {
     var displayName: string;
 }
-type ValueProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "className" | "style"> & {
-    placeholder?: React.ReactNode;
-    children?: UpstreamValue["children"];
-    className?: UpstreamValue["className"];
-    style?: UpstreamValue["style"];
-    render?: UpstreamValue["render"];
-};
 /** Select.Value — renders the currently-selected value (or placeholder). */
-export declare function Value({ className, children, ...props }: ValueProps): import("react/jsx-runtime").JSX.Element;
+export declare function Value({ children, ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Value {
     var displayName: string;
 }
-type IconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    className?: UpstreamIcon["className"];
-    style?: UpstreamIcon["style"];
-    render?: UpstreamIcon["render"];
-};
 /** Select.Icon — visual indicator (chevron) next to the value. */
-export declare function Icon({ className, ...props }: IconProps): import("react/jsx-runtime").JSX.Element;
+export declare function Icon(props: React.ComponentProps<typeof SelectPrimitive.Icon>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Icon {
     var displayName: string;
 }
-type PortalProps = {
-    container?: UpstreamPortal["container"];
-    className?: UpstreamPortal["className"];
-    style?: UpstreamPortal["style"];
-    render?: UpstreamPortal["render"];
-    children?: React.ReactNode;
-};
 /** Select.Portal — portals the popup tree to document.body (or a custom container). */
-export declare function Portal(props: PortalProps): import("react/jsx-runtime").JSX.Element;
+export declare function Portal(props: React.ComponentProps<typeof SelectPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Portal {
     var displayName: string;
 }
-type BackdropProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamBackdrop["className"];
-    style?: UpstreamBackdrop["style"];
-    render?: UpstreamBackdrop["render"];
-};
 /** Select.Backdrop — overlay behind the popup (visible only in modal mode). */
-export declare function Backdrop({ className, ...props }: BackdropProps): import("react/jsx-runtime").JSX.Element;
+export declare function Backdrop(props: React.ComponentProps<typeof SelectPrimitive.Backdrop>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Backdrop {
     var displayName: string;
 }
-type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    /** @default false */
-    alignItemWithTrigger?: UpstreamPositioner["alignItemWithTrigger"];
-    /** @default false */
-    disableAnchorTracking?: UpstreamPositioner["disableAnchorTracking"];
-    /** @default "start" */
-    align?: UpstreamPositioner["align"];
-    /** @default 0 */
-    alignOffset?: UpstreamPositioner["alignOffset"];
-    /** @default "bottom" */
-    side?: UpstreamPositioner["side"];
-    /** @default 0 */
-    sideOffset?: UpstreamPositioner["sideOffset"];
-    /** @default 'clipping-ancestors' */
-    collisionBoundary?: UpstreamPositioner["collisionBoundary"];
-    /** @default 5 */
-    collisionPadding?: UpstreamPositioner["collisionPadding"];
-    /** @default { fallbackAxisSide: 'none' } */
-    collisionAvoidance?: UpstreamPositioner["collisionAvoidance"];
-    className?: UpstreamPositioner["className"];
-    style?: UpstreamPositioner["style"];
-    render?: UpstreamPositioner["render"];
-};
 /** Select.Positioner — positions the popup relative to the trigger. */
-export declare function Positioner({ className, align, alignItemWithTrigger, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Positioner({ align, alignItemWithTrigger, ...props }: React.ComponentProps<typeof SelectPrimitive.Positioner>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Positioner {
     var displayName: string;
 }
-type PopupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamPopup["className"];
-    style?: UpstreamPopup["style"];
-    render?: UpstreamPopup["render"];
-};
 /** Select.Popup — dropdown surface. */
-export declare function Popup({ className, ...props }: PopupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Popup(props: React.ComponentProps<typeof SelectPrimitive.Popup>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Popup {
     var displayName: string;
 }
-type ArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamArrow["className"];
-    style?: UpstreamArrow["style"];
-    render?: UpstreamArrow["render"];
-};
 /** Select.Arrow — pointer arrow attached to the popup. */
-export declare function Arrow({ className, ...props }: ArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Arrow(props: React.ComponentProps<typeof SelectPrimitive.Arrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Arrow {
     var displayName: string;
 }
-type ListProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamList["className"];
-    style?: UpstreamList["style"];
-    render?: UpstreamList["render"];
-};
 /** Select.List — items container. */
-export declare function List({ className, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
+export declare function List(props: React.ComponentProps<typeof SelectPrimitive.List>): import("react/jsx-runtime").JSX.Element;
 export declare namespace List {
     var displayName: string;
 }
-type ItemProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
+interface ItemProps extends Omit<UpstreamItem, "value"> {
     value: UpstreamItem["value"];
-    /** @default false */
-    disabled?: UpstreamItem["disabled"];
-    className?: UpstreamItem["className"];
-    style?: UpstreamItem["style"];
-    render?: UpstreamItem["render"];
-};
+}
 /** Select.Item — individual selectable option. */
-export declare function Item({ className, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function Item(props: ItemProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Item {
     var displayName: string;
 }
-type ItemIndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    className?: UpstreamItemIndicator["className"];
-    style?: UpstreamItemIndicator["style"];
-    render?: UpstreamItemIndicator["render"];
-};
 /** Select.ItemIndicator — visual marker (e.g. checkmark) inside the selected item. */
-export declare function ItemIndicator({ className, ...props }: ItemIndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function ItemIndicator(props: React.ComponentProps<typeof SelectPrimitive.ItemIndicator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ItemIndicator {
     var displayName: string;
 }
-type ItemTextProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamItemText["className"];
-    style?: UpstreamItemText["style"];
-    render?: UpstreamItemText["render"];
-};
 /** Select.ItemText — text label for an item. */
-export declare function ItemText({ className, ...props }: ItemTextProps): import("react/jsx-runtime").JSX.Element;
+export declare function ItemText(props: React.ComponentProps<typeof SelectPrimitive.ItemText>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ItemText {
     var displayName: string;
 }
-type GroupProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamGroup["className"];
-    style?: UpstreamGroup["style"];
-    render?: UpstreamGroup["render"];
-};
 /** Select.Group — wrapper around a grouped set of items. */
-export declare function Group({ className, ...props }: GroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Group(props: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Group {
     var displayName: string;
 }
-type GroupLabelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamGroupLabel["className"];
-    style?: UpstreamGroupLabel["style"];
-    render?: UpstreamGroupLabel["render"];
-};
 /** Select.GroupLabel — heading for a Select.Group. */
-export declare function GroupLabel({ className, ...props }: GroupLabelProps): import("react/jsx-runtime").JSX.Element;
+export declare function GroupLabel(props: React.ComponentProps<typeof SelectPrimitive.GroupLabel>): import("react/jsx-runtime").JSX.Element;
 export declare namespace GroupLabel {
     var displayName: string;
 }
-type SeparatorProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamSeparator["className"];
-    style?: UpstreamSeparator["style"];
-    render?: UpstreamSeparator["render"];
-};
 /** Select.Separator — thin divider between items. */
-export declare function Separator({ className, ...props }: SeparatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function Separator(props: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Separator {
     var displayName: string;
 }
-type ScrollUpArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamScrollUpArrow["className"];
-    style?: UpstreamScrollUpArrow["style"];
-    render?: UpstreamScrollUpArrow["render"];
-};
 /** Select.ScrollUpArrow — indicator that more items exist above. */
-export declare function ScrollUpArrow({ className, ...props }: ScrollUpArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ScrollUpArrow(props: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ScrollUpArrow {
     var displayName: string;
 }
-type ScrollDownArrowProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    className?: UpstreamScrollDownArrow["className"];
-    style?: UpstreamScrollDownArrow["style"];
-    render?: UpstreamScrollDownArrow["render"];
-};
 /** Select.ScrollDownArrow — indicator that more items exist below. */
-export declare function ScrollDownArrow({ className, ...props }: ScrollDownArrowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ScrollDownArrow(props: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>): import("react/jsx-runtime").JSX.Element;
 export declare namespace ScrollDownArrow {
     var displayName: string;
 }

package/dist/components/separator/separator.d.ts

@@ -1,15 +1,16 @@
+import { Separator as SeparatorPrimitive } from '@base-ui/react/separator';
 import { VariantProps } from 'class-variance-authority';
+type UpstreamSeparator = React.ComponentProps<typeof SeparatorPrimitive>;
 declare const separator: (props?: ({
     variant?: "solid" | "dashed" | "dotted" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof separator> & {
-    orientation?: "horizontal" | "vertical";
-};
+interface Props extends UpstreamSeparator, VariantProps<typeof separator> {
+}
 /**
  * Separator — visual divider between content sections.
  *
  * @see https://base-ui.com/react/components/separator
  * @llm https://base-ui.com/react/components/separator.md
  */
-export declare function Separator({ orientation, variant, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Separator({ orientation, variant, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -15,5 +15,5 @@ type Props = Omit<React.HTMLAttributes<HTMLSpanElement>, "role"> & VariantProps<
  * `requestAnimationFrame` loop that rewrites the two `d` attributes directly —
  * no React re-render per frame. The loop pauses while the tab is hidden.
  */
-export declare function Spinner({ size, label, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Spinner({ size, label, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -14,5 +14,5 @@ type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof stack>;
  *
  * @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 {};