@photon-ai/pho-ui 0.1.0

package/dist/src/components/menu/menu.d.ts

@@ -0,0 +1,47 @@
+import { ComponentProps, ElementType } from 'react';
+import { Menu as BaseMenu } from '@base-ui/react/menu';
+import { Separator as BaseSeparator } from '@base-ui/react/separator';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+/** Shared popup + item styles, reused by `ContextMenu` and `Menubar` menus. */
+export declare const MENU_POPUP = "squircle bg-pho-primary text-pho-primary shadow-pho-lg ring-pho-interactive origin-[var(--transform-origin)] min-w-44 rounded-xl p-1 ring-1 ring-inset outline-none transition-[transform,opacity] duration-150 ease-out data-[starting-style]:scale-95 data-[starting-style]:opacity-0 data-[ending-style]:scale-95 data-[ending-style]:opacity-0";
+export declare const MENU_ITEM = "relative flex cursor-pointer items-center gap-2 rounded-lg py-1.5 pr-2.5 pl-2.5 text-sm text-pho-secondary outline-none select-none data-[highlighted]:bg-pho-secondary data-[highlighted]:text-pho-primary data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&>svg]:size-4 [&>svg]:text-fg-pho-quaternary";
+declare function Positioner({ className, sideOffset, ...props }: StyledProps<typeof BaseMenu.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseMenu.Popup>): import("react").JSX.Element;
+declare function Item({ className, ...props }: StyledProps<typeof BaseMenu.Item>): import("react").JSX.Element;
+declare function LinkItem({ className, ...props }: StyledProps<typeof BaseMenu.LinkItem>): import("react").JSX.Element;
+declare function GroupLabel({ className, ...props }: StyledProps<typeof BaseMenu.GroupLabel>): import("react").JSX.Element;
+declare function Separator({ className, ...props }: StyledProps<typeof BaseSeparator>): import("react").JSX.Element;
+declare function SubmenuTrigger({ className, ...props }: StyledProps<typeof BaseMenu.SubmenuTrigger>): import("react").JSX.Element;
+declare function CheckboxItem({ className, ...props }: StyledProps<typeof BaseMenu.CheckboxItem>): import("react").JSX.Element;
+declare function RadioItem({ className, ...props }: StyledProps<typeof BaseMenu.RadioItem>): import("react").JSX.Element;
+declare function CheckboxItemIndicator({ className, ...props }: StyledProps<typeof BaseMenu.CheckboxItemIndicator>): import("react").JSX.Element;
+declare function RadioItemIndicator({ className, ...props }: StyledProps<typeof BaseMenu.RadioItemIndicator>): import("react").JSX.Element;
+/**
+ * Dropdown menu built on Base UI `Menu` — a list of actions opened from a
+ * trigger. Supports grouped items, separators, submenus
+ * (`SubmenuRoot` + `SubmenuTrigger`), and stateful `CheckboxItem` /
+ * `RadioItem`s. For a right-click menu use `ContextMenu`.
+ */
+export declare const Menu: {
+    Root: <Payload>(props: BaseMenu.Root.Props<Payload>) => import("react").JSX.Element;
+    Trigger: BaseMenu.Trigger;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+    Item: typeof Item;
+    LinkItem: typeof LinkItem;
+    Group: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuGroupProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof GroupLabel;
+    Separator: typeof Separator;
+    SubmenuRoot: typeof BaseMenu.SubmenuRoot;
+    SubmenuTrigger: typeof SubmenuTrigger;
+    CheckboxItem: typeof CheckboxItem;
+    CheckboxItemIndicator: typeof CheckboxItemIndicator;
+    RadioGroup: import('react').NamedExoticComponent<Omit<import('@base-ui/react').ContextMenuRadioGroupProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    RadioItem: typeof RadioItem;
+    RadioItemIndicator: typeof RadioItemIndicator;
+};
+export {};

package/dist/src/components/menubar/index.d.ts

@@ -0,0 +1 @@
+export { Menubar, type MenubarProps } from './menubar';

package/dist/src/components/menubar/menubar.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProps } from 'react';
+import { Menubar as BaseMenubar } from '@base-ui/react/menubar';
+export interface MenubarProps extends Omit<ComponentProps<typeof BaseMenubar>, "className"> {
+    className?: string;
+}
+/**
+ * Horizontal bar of top-level menus, built on Base UI `Menubar` — the classic
+ * desktop-app menu strip (File / Edit / View). Place `Menu` components inside;
+ * the menubar coordinates roving focus and lets open menus switch on hover.
+ */
+export declare function Menubar({ className, ...props }: MenubarProps): import("react").JSX.Element;
+export declare namespace Menubar {
+    var displayName: string;
+}

package/dist/src/components/meter/index.d.ts

@@ -0,0 +1 @@
+export { Meter } from './meter';

package/dist/src/components/meter/meter.d.ts

@@ -0,0 +1,24 @@
+import { ComponentProps, ElementType } from 'react';
+import { Meter as BaseMeter } from '@base-ui/react/meter';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Root({ className, ...props }: StyledProps<typeof BaseMeter.Root>): import("react").JSX.Element;
+declare function Label({ className, ...props }: StyledProps<typeof BaseMeter.Label>): import("react").JSX.Element;
+declare function Value({ className, ...props }: StyledProps<typeof BaseMeter.Value>): import("react").JSX.Element;
+declare function Track({ className, ...props }: StyledProps<typeof BaseMeter.Track>): import("react").JSX.Element;
+declare function Indicator({ className, ...props }: StyledProps<typeof BaseMeter.Indicator>): import("react").JSX.Element;
+/**
+ * Meter built on Base UI `Meter`. Unlike `Progress`, a meter shows a static
+ * measurement within a known range (disk usage, score, capacity) rather than
+ * task completion. Set `value` on `Meter.Root`.
+ */
+export declare const Meter: {
+    Root: typeof Root;
+    Label: typeof Label;
+    Value: typeof Value;
+    Track: typeof Track;
+    Indicator: typeof Indicator;
+};
+export {};

package/dist/src/components/navigation-menu/index.d.ts

@@ -0,0 +1 @@
+export { NavigationMenu } from './navigation-menu';

package/dist/src/components/navigation-menu/navigation-menu.d.ts

@@ -0,0 +1,35 @@
+import { ComponentProps, ElementType } from 'react';
+import { NavigationMenu as BaseNav } from '@base-ui/react/navigation-menu';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Root({ className, ...props }: StyledProps<typeof BaseNav.Root>): import("react").JSX.Element;
+declare function List({ className, ...props }: StyledProps<typeof BaseNav.List>): import("react").JSX.Element;
+declare function Trigger({ className, ...props }: StyledProps<typeof BaseNav.Trigger>): import("react").JSX.Element;
+declare function Content({ className, ...props }: StyledProps<typeof BaseNav.Content>): import("react").JSX.Element;
+declare function Link({ className, ...props }: StyledProps<typeof BaseNav.Link>): import("react").JSX.Element;
+declare function Positioner({ className, sideOffset, ...props }: StyledProps<typeof BaseNav.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseNav.Popup>): import("react").JSX.Element;
+declare function Viewport({ className, ...props }: StyledProps<typeof BaseNav.Viewport>): import("react").JSX.Element;
+/**
+ * Site navigation menu built on Base UI `NavigationMenu` — a horizontal bar
+ * whose items open animated dropdown panels that resize to their content. Each
+ * `Item` pairs a `Trigger` with `Content` (rendered into the shared
+ * `Viewport`). Use it for primary site nav with grouped links; for app action
+ * menus use `Menu`.
+ */
+export declare const NavigationMenu: {
+    Root: typeof Root;
+    List: typeof List;
+    Item: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').NavigationMenuItemProps, "ref"> & import('react').RefAttributes<HTMLLIElement>>;
+    Trigger: typeof Trigger;
+    Content: typeof Content;
+    Link: typeof Link;
+    Icon: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').NavigationMenuIconProps, "ref"> & import('react').RefAttributes<HTMLSpanElement>>;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').NavigationMenuPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+    Viewport: typeof Viewport;
+};
+export {};

package/dist/src/components/notification/index.d.ts

@@ -0,0 +1 @@
+export { Notification, NOTIFICATION_COLORS, type NotificationColor, type NotificationProps, } from './notification';

package/dist/src/components/notification/notification.d.ts

@@ -0,0 +1,73 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+import { Icon } from '@phosphor-icons/react';
+/**
+ * Design notes (Geist-aligned):
+ * - ONE closed, semantic axis: `color`. It selects a status glyph *and* its
+ *   tint together — you never pick an icon and a color separately. This is the
+ *   `IconNotification` flavor from the app; the unused avatar/image variants of
+ *   the source family are intentionally dropped.
+ * - The action row is a single reduced pair: a brand `confirmLabel` link beside
+ *   a gray dismiss link. It appears only when there's something to confirm.
+ * - `onClose` is the only thing that renders the top-right close button — no
+ *   separate boolean flag to keep in sync.
+ */
+/** Status color → icon tint. A bare status-tinted glyph, no badge surface. */
+export declare const NOTIFICATION_COLORS: {
+    brand: {
+        classes: string;
+        description: string;
+    };
+    gray: {
+        classes: string;
+        description: string;
+    };
+    success: {
+        classes: string;
+        description: string;
+    };
+    warning: {
+        classes: string;
+        description: string;
+    };
+    error: {
+        classes: string;
+        description: string;
+    };
+};
+export type NotificationColor = keyof typeof NOTIFICATION_COLORS;
+export interface NotificationProps extends Omit<HTMLAttributes<HTMLDivElement>, "title" | "color"> {
+    /** Status color — selects the glyph and its tint. @default "brand" */
+    color?: NotificationColor;
+    /** Bold heading line. */
+    title: ReactNode;
+    /** Supporting line under the title. */
+    description?: ReactNode;
+    /** Confirm action label — renders a brand link paired with a dismiss link. */
+    confirmLabel?: string;
+    /** Called when the confirm link is clicked. */
+    onConfirm?: () => void;
+    /** Dismiss link label, shown beside the confirm link. @default "Dismiss" */
+    dismissLabel?: string;
+    /** Called on dismiss. Its presence also renders the top-right close button. */
+    onClose?: () => void;
+    /** Override the status glyph while keeping the color's tint. */
+    icon?: Icon;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Notification — the standalone status card ported from the app's
+ * `IconNotification`: a status glyph, a title/description, an optional
+ * confirm+dismiss link pair, and an optional close button. It is a *card*, not a
+ * lifecycle: it owns its surface but nothing about timing or stacking.
+ *
+ * For a transient, auto-stacking toast, drop it inside pho-ui's Base UI
+ * {@link Toast} — render it as the child of a `Toast.Root` whose own surface you
+ * neutralize (`className="bg-transparent p-0 shadow-none ring-0"`) so the
+ * manager owns motion and swipe while this card owns the look. For a choice the
+ * user must make, use `AlertDialog` instead.
+ */
+export declare function Notification({ color, title, description, confirmLabel, onConfirm, dismissLabel, onClose, icon, className, ref, ...props }: NotificationProps): import("react").JSX.Element;
+export declare namespace Notification {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { NumberField } from './number-field';

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

@@ -0,0 +1,28 @@
+import { ComponentProps, ElementType } from 'react';
+import { NumberField as BaseNumberField } from '@base-ui/react/number-field';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Root({ className, ...props }: StyledProps<typeof BaseNumberField.Root>): import("react").JSX.Element;
+declare function Group({ className, ...props }: StyledProps<typeof BaseNumberField.Group>): import("react").JSX.Element;
+declare function Decrement({ className, ...props }: StyledProps<typeof BaseNumberField.Decrement>): import("react").JSX.Element;
+declare function Increment({ className, ...props }: StyledProps<typeof BaseNumberField.Increment>): import("react").JSX.Element;
+declare function Input({ className, ...props }: StyledProps<typeof BaseNumberField.Input>): import("react").JSX.Element;
+declare function ScrubArea({ className, ...props }: StyledProps<typeof BaseNumberField.ScrubArea>): import("react").JSX.Element;
+/**
+ * Numeric input with stepper buttons, built on Base UI `NumberField`. Compose
+ * `NumberField.Group` with a `Decrement`, `Input`, and `Increment`; it handles
+ * clamping, keyboard step, and pointer scrubbing. Use it over a plain text
+ * input whenever the value is a number with a sensible range.
+ */
+export declare const NumberField: {
+    Root: typeof Root;
+    Group: typeof Group;
+    Decrement: typeof Decrement;
+    Increment: typeof Increment;
+    Input: typeof Input;
+    ScrubArea: typeof ScrubArea;
+    ScrubAreaCursor: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').NumberFieldScrubAreaCursorProps, "ref"> & import('react').RefAttributes<HTMLSpanElement>>;
+};
+export {};

package/dist/src/components/otp-field/index.d.ts

@@ -0,0 +1 @@
+export { OtpField, type OtpFieldProps } from './otp-field';

package/dist/src/components/otp-field/otp-field.d.ts

@@ -0,0 +1,17 @@
+import { ComponentProps } from 'react';
+import { OTPField as BaseOTPField } from '@base-ui/react/otp-field';
+export interface OtpFieldProps extends Omit<ComponentProps<typeof BaseOTPField.Root>, "className"> {
+    /** Class applied to the cell row. */
+    className?: string;
+    /** Number of single-character cells. */
+    length: number;
+}
+/**
+ * One-time-code input built on Base UI `OTPField` — a row of single-character
+ * cells with paste, arrow-key, and auto-advance handling. Control with `value`
+ * / `onValueChange`, or read the completed code via `onValueChange`.
+ */
+export declare function OtpField({ className, length, ...props }: OtpFieldProps): import("react").JSX.Element;
+export declare namespace OtpField {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { Popover } from './popover';

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

@@ -0,0 +1,27 @@
+import { ComponentProps, ElementType } from 'react';
+import { Popover as BasePopover } from '@base-ui/react/popover';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Positioner({ className, sideOffset, ...props }: StyledProps<typeof BasePopover.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BasePopover.Popup>): import("react").JSX.Element;
+declare function Title({ className, ...props }: StyledProps<typeof BasePopover.Title>): import("react").JSX.Element;
+declare function Description({ className, ...props }: StyledProps<typeof BasePopover.Description>): import("react").JSX.Element;
+/**
+ * Popover built on Base UI `Popover` — a click-triggered floating panel
+ * anchored to its trigger, for rich, interactive content (forms, menus of
+ * actions, details). Unlike a `Tooltip`, it can hold focusable controls and is
+ * dismissed by clicking away or pressing Escape.
+ */
+export declare const Popover: {
+    Root: typeof BasePopover.Root;
+    Trigger: BasePopover.Trigger;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').PopoverPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+    Title: typeof Title;
+    Description: typeof Description;
+    Close: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').PopoverCloseProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+};
+export {};

package/dist/src/components/preview-card/index.d.ts

@@ -0,0 +1 @@
+export { PreviewCard } from './preview-card';

package/dist/src/components/preview-card/preview-card.d.ts

@@ -0,0 +1,22 @@
+import { ComponentProps, ElementType } from 'react';
+import { PreviewCard as BasePreviewCard } from '@base-ui/react/preview-card';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Positioner({ className, sideOffset, ...props }: StyledProps<typeof BasePreviewCard.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BasePreviewCard.Popup>): import("react").JSX.Element;
+/**
+ * Preview card built on Base UI `PreviewCard` — a hover-triggered card that
+ * previews what's behind a link (a profile, a repo, an article). Like a
+ * `Tooltip` it opens on hover/focus, but it holds richer, non-essential
+ * content. Keep the underlying link fully usable without opening the card.
+ */
+export declare const PreviewCard: {
+    Root: <Payload>(props: BasePreviewCard.Root.Props<Payload>) => import("react").JSX.Element;
+    Trigger: BasePreviewCard.Trigger;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').PreviewCardPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+};
+export {};

package/dist/src/components/progress/index.d.ts

@@ -0,0 +1 @@
+export { Progress } from './progress';

package/dist/src/components/progress/progress.d.ts

@@ -0,0 +1,24 @@
+import { ComponentProps, ElementType } from 'react';
+import { Progress as BaseProgress } from '@base-ui/react/progress';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Root({ className, ...props }: StyledProps<typeof BaseProgress.Root>): import("react").JSX.Element;
+declare function Label({ className, ...props }: StyledProps<typeof BaseProgress.Label>): import("react").JSX.Element;
+declare function Value({ className, ...props }: StyledProps<typeof BaseProgress.Value>): import("react").JSX.Element;
+declare function Track({ className, ...props }: StyledProps<typeof BaseProgress.Track>): import("react").JSX.Element;
+declare function Indicator({ className, ...props }: StyledProps<typeof BaseProgress.Indicator>): import("react").JSX.Element;
+/**
+ * Determinate progress bar built on Base UI `Progress`. Set `value` (0–100, or
+ * `null` for indeterminate) on `Progress.Root`; Base UI sizes the indicator.
+ * Compose a header row with `Progress.Label` + `Progress.Value`.
+ */
+export declare const Progress: {
+    Root: typeof Root;
+    Label: typeof Label;
+    Value: typeof Value;
+    Track: typeof Track;
+    Indicator: typeof Indicator;
+};
+export {};

package/dist/src/components/radio-group/index.d.ts

@@ -0,0 +1 @@
+export { RadioGroup, Radio, type RadioGroupProps, type RadioProps, } from './radio-group';

package/dist/src/components/radio-group/radio-group.d.ts

@@ -0,0 +1,28 @@
+import { ComponentProps, ReactNode } from 'react';
+import { RadioGroup as BaseRadioGroup } from '@base-ui/react/radio-group';
+import { Radio as BaseRadio } from '@base-ui/react/radio';
+export interface RadioGroupProps extends Omit<ComponentProps<typeof BaseRadioGroup>, "className"> {
+    className?: string;
+}
+/**
+ * Single-choice group built on Base UI `RadioGroup`. Holds `Radio` items;
+ * exactly one may be selected. Control with `value` / `onValueChange` or leave
+ * uncontrolled with `defaultValue`.
+ */
+export declare function RadioGroup({ className, ...props }: RadioGroupProps): import("react").JSX.Element;
+export declare namespace RadioGroup {
+    var displayName: string;
+}
+export interface RadioProps extends Omit<ComponentProps<typeof BaseRadio.Root>, "className"> {
+    className?: string;
+    /** Text rendered beside the dot; the whole row selects this option. */
+    label?: ReactNode;
+}
+/**
+ * A single option within a `RadioGroup`. Requires a `value`; pass `label` for a
+ * clickable text row or provide an `aria-label`.
+ */
+export declare function Radio({ className, label, ...props }: RadioProps): import("react").JSX.Element;
+export declare namespace Radio {
+    var displayName: string;
+}

package/dist/src/components/scroll-area/index.d.ts

@@ -0,0 +1 @@
+export { ScrollArea } from './scroll-area';

package/dist/src/components/scroll-area/scroll-area.d.ts

@@ -0,0 +1,25 @@
+import { ComponentProps, ElementType } from 'react';
+import { ScrollArea as BaseScrollArea } from '@base-ui/react/scroll-area';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Root({ className, ...props }: StyledProps<typeof BaseScrollArea.Root>): import("react").JSX.Element;
+declare function Viewport({ className, ...props }: StyledProps<typeof BaseScrollArea.Viewport>): import("react").JSX.Element;
+declare function Scrollbar({ className, ...props }: StyledProps<typeof BaseScrollArea.Scrollbar>): import("react").JSX.Element;
+declare function Thumb({ className, ...props }: StyledProps<typeof BaseScrollArea.Thumb>): import("react").JSX.Element;
+/**
+ * Scroll area built on Base UI `ScrollArea` — a region with custom, overlay
+ * scrollbars that match the design system instead of the native ones. Give
+ * `ScrollArea.Root` a fixed size; put scrollable content in `Viewport` →
+ * `Content` and add a `Scrollbar` → `Thumb` per axis.
+ */
+export declare const ScrollArea: {
+    Root: typeof Root;
+    Viewport: typeof Viewport;
+    Content: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ScrollAreaContentProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Scrollbar: typeof Scrollbar;
+    Thumb: typeof Thumb;
+    Corner: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ScrollAreaCornerProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Select } from './select';

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

@@ -0,0 +1,36 @@
+import { ComponentProps, ElementType } from 'react';
+import { Select as BaseSelect } from '@base-ui/react/select';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Trigger({ className, ...props }: StyledProps<typeof BaseSelect.Trigger>): import("react").JSX.Element;
+declare function Icon({ className, ...props }: StyledProps<typeof BaseSelect.Icon>): import("react").JSX.Element;
+declare function Positioner({ className, sideOffset, ...props }: StyledProps<typeof BaseSelect.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseSelect.Popup>): import("react").JSX.Element;
+declare function Item({ className, ...props }: StyledProps<typeof BaseSelect.Item>): import("react").JSX.Element;
+declare function ItemIndicator({ className, ...props }: StyledProps<typeof BaseSelect.ItemIndicator>): import("react").JSX.Element;
+declare function GroupLabel({ className, ...props }: StyledProps<typeof BaseSelect.GroupLabel>): import("react").JSX.Element;
+/**
+ * Select built on Base UI `Select` — pick one option (or several with
+ * `multiple`) from a list that opens on click. Pass `items` to `Select.Root`,
+ * render an `Item` per option, and show the selection with `Select.Value`. For
+ * a short, always-visible set use `RadioGroup`; to filter a long list by typing
+ * use `Combobox`.
+ */
+export declare const Select: {
+    Root: typeof BaseSelect.Root;
+    Trigger: typeof Trigger;
+    Value: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectValueProps, "ref"> & import('react').RefAttributes<HTMLSpanElement>>;
+    Icon: typeof Icon;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+    List: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectListProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Item: typeof Item;
+    ItemText: import('react').NamedExoticComponent<Omit<import('@base-ui/react').SelectItemTextProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    ItemIndicator: typeof ItemIndicator;
+    Group: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').SelectGroupProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof GroupLabel;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Separator, type SeparatorProps } from './separator';

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

@@ -0,0 +1,14 @@
+import { ComponentProps } from 'react';
+import { Separator as BaseSeparator } from '@base-ui/react/separator';
+export interface SeparatorProps extends Omit<ComponentProps<typeof BaseSeparator>, "className"> {
+    className?: string;
+}
+/**
+ * A thin rule that divides content. Built on Base UI `Separator`. For a
+ * vertical rule set `orientation="vertical"` — the parent must give it height
+ * (e.g. a flex row with `items-stretch`).
+ */
+export declare function Separator({ className, ...props }: SeparatorProps): import("react").JSX.Element;
+export declare namespace Separator {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { Slider } from './slider';

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

@@ -0,0 +1,30 @@
+import { ComponentProps, ElementType } from 'react';
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Root({ className, ...props }: StyledProps<typeof BaseSlider.Root>): import("react").JSX.Element;
+declare function Label({ className, ...props }: StyledProps<typeof BaseSlider.Label>): import("react").JSX.Element;
+declare function Value({ className, ...props }: StyledProps<typeof BaseSlider.Value>): import("react").JSX.Element;
+declare function Control({ className, ...props }: StyledProps<typeof BaseSlider.Control>): import("react").JSX.Element;
+declare function Track({ className, ...props }: StyledProps<typeof BaseSlider.Track>): import("react").JSX.Element;
+declare function Indicator({ className, ...props }: StyledProps<typeof BaseSlider.Indicator>): import("react").JSX.Element;
+declare function Thumb({ className, ...props }: StyledProps<typeof BaseSlider.Thumb>): import("react").JSX.Element;
+/**
+ * Slider built on Base UI `Slider` for picking a number (or range) along a
+ * track. Compose a header with `Slider.Label` + `Slider.Value`, then
+ * `Slider.Control` → `Track` → `Indicator` + `Thumb`. Set `value` /
+ * `defaultValue`, `min`, `max`, `step` on `Slider.Root`. For a precise typed
+ * number, prefer `NumberField`.
+ */
+export declare const Slider: {
+    Root: typeof Root;
+    Label: typeof Label;
+    Value: typeof Value;
+    Control: typeof Control;
+    Track: typeof Track;
+    Indicator: typeof Indicator;
+    Thumb: typeof Thumb;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Switch, type SwitchProps, type SwitchSize } from './switch';

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

@@ -0,0 +1,18 @@
+import { ComponentProps } from 'react';
+import { Switch as BaseSwitch } from '@base-ui/react/switch';
+export type SwitchSize = "sm" | "md";
+export interface SwitchProps extends Omit<ComponentProps<typeof BaseSwitch.Root>, "className"> {
+    className?: string;
+    /** Size variant. @default "md" */
+    size?: SwitchSize;
+}
+/**
+ * On/off toggle built on Base UI `Switch`. Use a switch for a setting that
+ * takes effect immediately; use a `Checkbox` for a value confirmed on submit.
+ * Controlled via `checked` / `onCheckedChange` or uncontrolled via
+ * `defaultChecked`. Always provide a label or `aria-label`.
+ */
+export declare function Switch({ className, size, ...props }: SwitchProps): import("react").JSX.Element;
+export declare namespace Switch {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { Tabs } from './tabs';

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

@@ -0,0 +1,24 @@
+import { ComponentProps, ElementType } from 'react';
+import { Tabs as BaseTabs } from '@base-ui/react/tabs';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function List({ className, ...props }: StyledProps<typeof BaseTabs.List>): import("react").JSX.Element;
+declare function Tab({ className, ...props }: StyledProps<typeof BaseTabs.Tab>): import("react").JSX.Element;
+declare function Indicator({ className, ...props }: StyledProps<typeof BaseTabs.Indicator>): import("react").JSX.Element;
+declare function Panel({ className, ...props }: StyledProps<typeof BaseTabs.Panel>): import("react").JSX.Element;
+/**
+ * Tabbed sections built on Base UI `Tabs`, with an underline `Indicator` that
+ * slides to the active tab. Each `Tabs.Tab` and `Tabs.Panel` share a `value`.
+ * Control with `value` / `onValueChange` or leave uncontrolled via
+ * `defaultValue`.
+ */
+export declare const Tabs: {
+    Root: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').TabsRootProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    List: typeof List;
+    Tab: typeof Tab;
+    Indicator: typeof Indicator;
+    Panel: typeof Panel;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Toast } from './toast';

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

@@ -0,0 +1,34 @@
+import { ComponentProps, ElementType } from 'react';
+import { Toast as BaseToast } from '@base-ui/react/toast';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Viewport({ className, ...props }: StyledProps<typeof BaseToast.Viewport>): import("react").JSX.Element;
+declare function Root({ className, ...props }: StyledProps<typeof BaseToast.Root>): import("react").JSX.Element;
+declare function Content({ className, ...props }: StyledProps<typeof BaseToast.Content>): import("react").JSX.Element;
+declare function Title({ className, ...props }: StyledProps<typeof BaseToast.Title>): import("react").JSX.Element;
+declare function Description({ className, ...props }: StyledProps<typeof BaseToast.Description>): import("react").JSX.Element;
+declare function Close({ className, ...props }: StyledProps<typeof BaseToast.Close>): import("react").JSX.Element;
+/**
+ * Toast built on Base UI `Toast` — a transient, non-blocking notification.
+ * Wrap your app in `Toast.Provider`, render a `Toast.Portal` → `Viewport` that
+ * maps `useToastManager().toasts` to `Toast.Root`s, then call
+ * `useToastManager().add({ title, description })` to show one. Use a toast for
+ * confirmation of a background action; for a choice the user must make, use
+ * `AlertDialog`.
+ */
+export declare const Toast: {
+    Provider: import('react').FC<import('@base-ui/react').ToastProviderProps>;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import("node_modules/@base-ui/react/utils/FloatingPortalLite.mjs").FloatingPortalLite.Props<any>, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Viewport: typeof Viewport;
+    Root: typeof Root;
+    Content: typeof Content;
+    Title: typeof Title;
+    Description: typeof Description;
+    Close: typeof Close;
+    Action: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ToastActionProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+    useToastManager: typeof BaseToast.useToastManager;
+    createToastManager: typeof BaseToast.createToastManager;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Toggle, TOGGLE_SIZES, type ToggleProps, type ToggleSize, } from './toggle';