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

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, ...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 {};

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

@@ -1,23 +1,6 @@
 import { ToggleGroup as ToggleGroupPrimitive } from '@base-ui/react/toggle-group';
-type UpstreamRoot = React.ComponentProps<typeof ToggleGroupPrimitive>;
-type Props = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style" | "defaultValue"> & {
-    /** Values of the currently pressed items (controlled). Always an array, even in single-select. */
-    value?: UpstreamRoot["value"];
-    /** Values of the initially pressed items (uncontrolled). */
-    defaultValue?: UpstreamRoot["defaultValue"];
-    onValueChange?: UpstreamRoot["onValueChange"];
-    /** @default false */
-    multiple?: UpstreamRoot["multiple"];
-    /** @default false */
-    disabled?: UpstreamRoot["disabled"];
-    /** @default "horizontal" */
-    orientation?: UpstreamRoot["orientation"];
-    /** @default true */
-    loopFocus?: UpstreamRoot["loopFocus"];
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
+interface Props extends React.ComponentProps<typeof ToggleGroupPrimitive> {
+}
 /**
  * ToggleGroup - a set of connected `Toggle`s sharing one value. Single-select by
  * default (a segmented control); set `multiple` for multi-select. Compose one
@@ -26,5 +9,5 @@ type Props = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style" |
  * @doc https://base-ui.com/react/components/toggle-group
  * @llm https://base-ui.com/react/components/toggle-group.md
  */
-export declare function ToggleGroup({ className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function ToggleGroup(props: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/tooltip/tooltip.d.ts

@@ -1,21 +1,14 @@
 import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
-type UpstreamProvider = React.ComponentProps<typeof TooltipPrimitive.Provider>;
+import { VariantProps } from 'class-variance-authority';
 type UpstreamTrigger = React.ComponentProps<typeof TooltipPrimitive.Trigger>;
-type UpstreamPortal = React.ComponentProps<typeof TooltipPrimitive.Portal>;
-type UpstreamPositioner = React.ComponentProps<typeof TooltipPrimitive.Positioner>;
-type UpstreamPopup = React.ComponentProps<typeof TooltipPrimitive.Popup>;
-type UpstreamArrow = React.ComponentProps<typeof TooltipPrimitive.Arrow>;
-type UpstreamViewport = React.ComponentProps<typeof TooltipPrimitive.Viewport>;
+declare const tooltipTrigger: (props?: ({
+    variant?: "primary" | "secondary" | "positive" | "negative" | null | undefined;
+    inline?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const tooltipPopup: (props?: ({
+    variant?: "primary" | "secondary" | "positive" | "negative" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export declare const createHandle: typeof TooltipPrimitive.createHandle;
-type ProviderProps = {
-    /** @default undefined */
-    delay?: UpstreamProvider["delay"];
-    /** @default undefined */
-    closeDelay?: UpstreamProvider["closeDelay"];
-    /** @default 400 */
-    timeout?: UpstreamProvider["timeout"];
-    children?: UpstreamProvider["children"];
-};
 /**
  * Tooltip.Provider — shares open/close delay across a group of tooltips so
  * moving between neighbouring triggers feels instant. Renders no DOM element.
@@ -23,7 +16,7 @@ type ProviderProps = {
  * @see https://base-ui.com/react/components/tooltip
  * @llm https://base-ui.com/react/components/tooltip.md
  */
-export declare function Provider(props: ProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function Provider(props: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Provider {
     var displayName: string;
 }
@@ -38,103 +31,51 @@ 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?: "primary" | "secondary" | "positive" | "negative";
-    inline?: boolean;
+interface TriggerProps extends UpstreamTrigger, VariantProps<typeof tooltipTrigger> {
     /**
-     * Milliseconds to wait before opening on hover. Defaults to a snappier value
-     * than Base UI's 600ms — a deliberate imf default per "make the correct
-     * choice the easy one". Grouped triggers under a `Tooltip.Provider` open
-     * instantly after the first regardless of this value.
+     * Milliseconds to wait before opening on hover. Defaults to less than Base
+     * UI's 600ms, deliberately. Grouped triggers under a `Tooltip.Provider` open instantly
+     * after the first, regardless of this value.
      */
     delay?: UpstreamTrigger["delay"];
-    /** @default 0 */
-    closeDelay?: UpstreamTrigger["closeDelay"];
-    /** @default false */
-    disabled?: UpstreamTrigger["disabled"];
-    handle?: UpstreamTrigger["handle"];
-    payload?: UpstreamTrigger["payload"];
-    className?: UpstreamTrigger["className"];
-    render?: UpstreamTrigger["render"];
-};
+}
 /** Tooltip.Trigger — element that reveals the tooltip on hover or focus. */
-export declare function Trigger({ variant, inline, delay, className, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Trigger({ variant, inline, delay, ...props }: TriggerProps): 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"];
-};
 /** Tooltip.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 TooltipPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Portal {
     var displayName: string;
 }
-type PositionerProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className"> & {
-    /** @default 'top' */
-    side?: UpstreamPositioner["side"];
-    /** @default 'center' */
-    align?: UpstreamPositioner["align"];
-    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"];
-};
 /**
  * Tooltip.Positioner — positions the popup relative to the trigger via
  * floating-point layout.
  *
- * `sideOffset` defaults to `--arrow-size` (tooltip.module.css) + 4px — enough
- * gap for the arrow to bridge with a few px of breathing room past its tip,
- * rather than landing flush on the trigger. Keep the two in sync if either
- * changes.
+ * `sideOffset` defaults to `--arrow-size` (tooltip.module.css) + 4px, for
+ * gap past the arrow tip. Keep the two values in sync.
  */
-export declare function Positioner({ className, sideOffset, ...props }: PositionerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Positioner({ sideOffset, ...props }: React.ComponentProps<typeof TooltipPrimitive.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 TooltipPrimitive.Popup>, VariantProps<typeof tooltipPopup> {
     /** Match to the Trigger variant to tint the popup border accordingly. */
-    variant?: "primary" | "secondary" | "positive" | "negative";
-    className?: UpstreamPopup["className"];
-    render?: UpstreamPopup["render"];
-};
+    variant?: VariantProps<typeof tooltipPopup>["variant"];
+}
 /** Tooltip.Popup — the visible label surface. Token-mapped background and border, flat by brand default. */
-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"];
-};
 /** Tooltip.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 TooltipPrimitive.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"];
-};
 /** Tooltip.Viewport — content wrapper that supports direction-aware animations when content swaps. */
-export declare function Viewport({ className, ...props }: ViewportProps): import("react/jsx-runtime").JSX.Element;
+export declare function Viewport(props: React.ComponentProps<typeof TooltipPrimitive.Viewport>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Viewport {
     var displayName: string;
 }
@@ -146,7 +87,7 @@ type InlineProps = {
     /** Hover delay in ms before the tooltip opens. @default 150 */
     delay?: number;
     /** Which side of the trigger the popup appears on. @default 'top' */
-    side?: UpstreamPositioner["side"];
+    side?: React.ComponentProps<typeof TooltipPrimitive.Positioner>["side"];
     /** Gap between trigger and popup in px. @default 13 */
     sideOffset?: number;
 };