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

package/dist/components/number-field/number-field.d.ts

@@ -0,0 +1,72 @@
+import { NumberField as NumberFieldPrimitive } from '@base-ui/react/number-field';
+import { VariantProps } from 'class-variance-authority';
+declare const numberFieldRoot: (props?: ({
+    width?: "auto" | "full" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const numberFieldGroup: (props?: ({
+    variant?: "primary" | "outline" | "ghost" | "filled" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface RootProps extends React.ComponentProps<typeof NumberFieldPrimitive.Root> {
+    /** Width behavior: `auto` uses intrinsic width; `full` fills the parent. @default "auto" */
+    width?: VariantProps<typeof numberFieldRoot>["width"];
+}
+export declare function Root({ width, step, format, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Root {
+    var displayName: string;
+}
+interface GroupProps extends React.ComponentProps<typeof NumberFieldPrimitive.Group>, VariantProps<typeof numberFieldGroup> {
+}
+/** NumberField.Group — bordered box grouping the input with the stepper controls. */
+export declare function Group({ variant, size, ...props }: GroupProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Group {
+    var displayName: string;
+}
+/** NumberField.Input — transparent, borderless mono numeric field. */
+export declare function Input(props: React.ComponentProps<typeof NumberFieldPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Input {
+    var displayName: string;
+}
+/** NumberField.Increment — full-height square control that increases the value. */
+export declare function Increment(props: React.ComponentProps<typeof NumberFieldPrimitive.Increment>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Increment {
+    var displayName: string;
+}
+/** NumberField.Decrement — full-height square control that decreases the value. */
+export declare function Decrement(props: React.ComponentProps<typeof NumberFieldPrimitive.Decrement>): import("react/jsx-runtime").JSX.Element;
+export declare namespace Decrement {
+    var displayName: string;
+}
+/** NumberField.ScrubArea — draggable region that scrubs the value on pointer move. */
+export declare function ScrubArea(props: React.ComponentProps<typeof NumberFieldPrimitive.ScrubArea>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScrubArea {
+    var displayName: string;
+}
+/** NumberField.ScrubAreaCursor — virtual cursor shown while scrubbing under pointer lock. */
+export declare function ScrubAreaCursor(props: React.ComponentProps<typeof NumberFieldPrimitive.ScrubAreaCursor>): import("react/jsx-runtime").JSX.Element;
+export declare namespace ScrubAreaCursor {
+    var displayName: string;
+}
+interface StepperProps extends RootProps, VariantProps<typeof numberFieldGroup> {
+    /** Control placement relative to the input. @default "trailing" */
+    layout?: "trailing" | "flanking";
+    /** Surface treatment applied to the group. @default "outline" */
+    variant?: "outline" | "primary" | "filled" | "ghost";
+    /** Control height, matching Input's scale. @default "md" */
+    size?: "sm" | "md" | "lg";
+    /**
+     * Drag handle rendered above the field: press and move sideways to change the value, usually
+     * the field's label. The scrub cursor is supplied automatically.
+     */
+    scrub?: React.ReactNode;
+}
+/**
+ * NumberField.Stepper — pre-composed Root → Group → Input + controls. Use the
+ * individual parts instead when a custom composition (e.g. with `Field` or
+ * `ScrubArea`) is needed.
+ */
+export declare function Stepper({ layout, variant, size, width, scrub, ...props }: StepperProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Stepper {
+    var displayName: string;
+}
+export {};

package/dist/components/number-field/number-field.meta.d.ts

@@ -0,0 +1,2 @@
+import { ComponentMeta } from '../../types/meta';
+export declare const numberFieldMeta: ComponentMeta;

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

@@ -1,14 +1,12 @@
 import { Popover as PopoverPrimitive } from '@base-ui/react/popover';
-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>;
+import { VariantProps } from 'class-variance-authority';
+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 +19,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 }: React.ComponentProps<typeof PopoverPrimitive.Trigger> & 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 React.ComponentProps<typeof PopoverPrimitive.Popup>, 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;
 }
@@ -163,7 +88,7 @@ type InlineProps = {
     /** Hover delay in ms before the popover opens. @default 150 */
     delay?: number;
     /** Which side of the trigger the popup appears on. @default 'top' */
-    side?: UpstreamPositioner["side"];
+    side?: React.ComponentProps<typeof PopoverPrimitive.Positioner>["side"];
     /** Gap between trigger and popup in px. @default 6 */
     sideOffset?: number;
 };

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,277 +1,114 @@
 import { Select as SelectPrimitive } from '@base-ui/react/select';
-type UpstreamRoot = React.ComponentProps<typeof SelectPrimitive.Root>;
-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?: UpstreamRoot["value"];
-    defaultValue?: UpstreamRoot["defaultValue"];
-    onValueChange?: UpstreamRoot["onValueChange"];
-    /** @default false */
-    defaultOpen?: UpstreamRoot["defaultOpen"];
-    open?: UpstreamRoot["open"];
-    onOpenChange?: UpstreamRoot["onOpenChange"];
-    onOpenChangeComplete?: UpstreamRoot["onOpenChangeComplete"];
-    /** @default false */
-    multiple?: UpstreamRoot["multiple"];
-    /** @default false */
-    disabled?: UpstreamRoot["disabled"];
-    /** @default false */
-    readOnly?: UpstreamRoot["readOnly"];
-    /** @default false */
-    required?: UpstreamRoot["required"];
-    /** @default true */
-    modal?: UpstreamRoot["modal"];
-    /** @default true */
-    highlightItemOnHover?: UpstreamRoot["highlightItemOnHover"];
-    items?: UpstreamRoot["items"];
-    isItemEqualToValue?: UpstreamRoot["isItemEqualToValue"];
-    itemToStringLabel?: UpstreamRoot["itemToStringLabel"];
-    itemToStringValue?: UpstreamRoot["itemToStringValue"];
-    autoComplete?: UpstreamRoot["autoComplete"];
-    form?: UpstreamRoot["form"];
-    inputRef?: UpstreamRoot["inputRef"];
-    actionsRef?: UpstreamRoot["actionsRef"];
-    name?: UpstreamRoot["name"];
-    id?: UpstreamRoot["id"];
-    children?: React.ReactNode;
-};
+interface RootProps<Value = unknown, Multiple extends boolean | undefined = false> extends React.ComponentProps<typeof SelectPrimitive.Root<Value, Multiple>> {
+}
 /**
  * Select.Root — accessible select / listbox primitive.
  *
- * Renders a thin wrapper div so that a sibling Select.Label stacks above the
- * Select.Trigger regardless of the parent's layout. Select.Portal is unaffected
- * (it renders to document.body).
+ * Wraps children in a div so a sibling Select.Label stacks above Select.Trigger
+ * regardless of the parent's layout. Select.Portal is unaffected (it renders to
+ * document.body).
  *
  * @doc https://base-ui.com/react/components/select
  * @llm https://base-ui.com/react/components/select.md
  */
-export declare function Root({ className, style, ...props }: RootProps & {
+export declare function Root<Value = unknown, Multiple extends boolean | undefined = false>({ className, style, ...props }: RootProps<Value, Multiple> & {
     className?: string;
     style?: React.CSSProperties;
 }): 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"];
-};
 /** 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';
 declare const separator: (props?: ({
     variant?: "solid" | "dashed" | "dotted" | null | undefined;
+    spacing?: "none" | "small" | "medium" | "large" | "spacious" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type Props = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof separator> & {
-    orientation?: "horizontal" | "vertical";
-};
+interface Props extends React.ComponentProps<typeof SeparatorPrimitive>, 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, spacing, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};