@photon-ai/pho-ui 0.1.0

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

@@ -0,0 +1,196 @@
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, FC, ReactNode, Ref } from 'react';
+/** Size axis — padding, text size, and icon-only (svgOnly) padding. */
+export declare const BUTTON_SIZES: {
+    sm: {
+        classes: string;
+        description: string;
+    };
+    md: {
+        classes: string;
+        description: string;
+    };
+    lg: {
+        classes: string;
+        description: string;
+    };
+};
+/** Shape axis — corner treatment. `square` is the default text-button shape. */
+export declare const BUTTON_SHAPES: {
+    square: {
+        classes: string;
+        description: string;
+    };
+    circle: {
+        classes: string;
+        description: string;
+    };
+    rounded: {
+        classes: string;
+        description: string;
+    };
+};
+/** Emphasis axis — a tight, semantic set. `primary` is the default. */
+export declare const BUTTON_VARIANTS: {
+    primary: {
+        classes: string;
+        description: string;
+    };
+    secondary: {
+        classes: string;
+        description: string;
+    };
+    tertiary: {
+        classes: string;
+        description: string;
+    };
+    error: {
+        classes: string;
+        description: string;
+    };
+};
+export type ButtonSize = keyof typeof BUTTON_SIZES;
+export type ButtonShape = keyof typeof BUTTON_SHAPES;
+export type ButtonVariant = keyof typeof BUTTON_VARIANTS;
+/** Compose the full class string for a button — exported for reuse/testing. */
+export declare function buttonVariants(opts?: {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    shape?: ButtonShape;
+    shadow?: boolean;
+    className?: string;
+}): string;
+/** An icon/element slot rendered before or after the label. */
+type Slottable = ReactNode | FC<{
+    className?: string;
+}>;
+interface ButtonBaseProps {
+    /** Emphasis variant. @default "primary" */
+    variant?: ButtonVariant;
+    /** Size variant. @default "md" */
+    size?: ButtonSize;
+    /** Corner shape. @default "square" */
+    shape?: ButtonShape;
+    /** Add an elevation shadow (marketing / `rounded`). */
+    shadow?: boolean;
+    /** Slot before the label — a component (`Plus`) or element (`<Plus />`). */
+    prefix?: Slottable;
+    /** Slot after the label. */
+    suffix?: Slottable;
+    /** Render as an icon-only button. Requires an `aria-label`. */
+    svgOnly?: boolean;
+    /** Show a spinner and block interaction while staying readable. */
+    loading?: boolean;
+    children?: ReactNode;
+    className?: string;
+}
+export interface ButtonProps extends ButtonBaseProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, keyof ButtonBaseProps> {
+    ref?: Ref<HTMLButtonElement>;
+}
+export interface ButtonLinkProps extends ButtonBaseProps, Omit<AnchorHTMLAttributes<HTMLAnchorElement>, keyof ButtonBaseProps> {
+    /** Navigate to this URL (rendered via the host's `LinkProvider`). */
+    href: string;
+    /** Visually and semantically disable the link. */
+    disabled?: boolean;
+}
+/**
+ * Button — triggers an action that mutates state (submit, save, delete).
+ * For navigation that changes the URL, use {@link ButtonLink}.
+ */
+export declare function Button({ variant, size, shape, shadow, prefix, suffix, svgOnly, loading, children, className, ref, ...props }: ButtonProps): import("react").JSX.Element;
+export declare namespace Button {
+    var displayName: string;
+}
+/**
+ * ButtonLink — a link styled as a button, for navigation that changes the URL.
+ * Shares every visual prop with {@link Button}; renders the host router's link
+ * via `LinkProvider`.
+ */
+export declare function ButtonLink({ variant, size, shape, shadow, prefix, suffix, svgOnly, loading, disabled, href, children, className, ...props }: ButtonLinkProps): import("react").JSX.Element;
+export declare namespace ButtonLink {
+    var displayName: string;
+}
+/** Size axis for {@link EffectButton} — padding + label size per source variant. */
+export declare const EFFECT_BUTTON_SIZES: {
+    sm: {
+        classes: string;
+        description: string;
+    };
+    md: {
+        classes: string;
+        description: string;
+    };
+};
+/**
+ * Emphasis axis for {@link EffectButton} — the static fill + edge treatment.
+ * `secondary` reuses the white-card surface tokens of Button's `secondary`
+ * (white card, hairline ring, quiet hover) and skips the glossy sheen — that
+ * inset shine is the brand-fill treatment.
+ */
+export declare const EFFECT_BUTTON_VARIANTS: {
+    primary: {
+        classes: string;
+        description: string;
+    };
+    secondary: {
+        classes: string;
+        description: string;
+    };
+};
+export type EffectButtonSize = keyof typeof EFFECT_BUTTON_SIZES;
+export type EffectButtonVariant = keyof typeof EFFECT_BUTTON_VARIANTS;
+/** Compose the static class string for an effect button — exported for reuse. */
+export declare function effectButtonVariants(opts?: {
+    variant?: EffectButtonVariant;
+    size?: EffectButtonSize;
+    fullWidth?: boolean;
+    className?: string;
+}): string;
+type MotionConflicts = "onAnimationStart" | "onAnimationEnd" | "onAnimationIteration" | "onDrag" | "onDragStart" | "onDragEnd" | "onDragEnter" | "onDragExit" | "onDragLeave" | "onDragOver" | "onDrop" | "style";
+interface EffectButtonBaseProps {
+    /** Emphasis variant. @default "primary" */
+    variant?: EffectButtonVariant;
+    /** Size variant. @default "md" */
+    size?: EffectButtonSize;
+    /** Stretch to the container's full width (stacked login / OAuth pills). */
+    fullWidth?: boolean;
+    /** Slot before the label — a component (`Plus`) or element (`<Plus />`). */
+    prefix?: Slottable;
+    /** Slot after the label. */
+    suffix?: Slottable;
+    /** Render as an icon-only button. Requires an `aria-label`. */
+    svgOnly?: boolean;
+    /** Show a spinner and block interaction while staying readable. */
+    loading?: boolean;
+    children?: ReactNode;
+    className?: string;
+}
+export interface EffectButtonProps extends EffectButtonBaseProps, Omit<ButtonHTMLAttributes<HTMLButtonElement>, keyof EffectButtonBaseProps | MotionConflicts> {
+    ref?: Ref<HTMLButtonElement>;
+}
+export interface EffectButtonLinkProps extends EffectButtonBaseProps, Omit<AnchorHTMLAttributes<HTMLAnchorElement>, keyof EffectButtonBaseProps | MotionConflicts> {
+    /** Navigate to this URL (rendered via the host's `LinkProvider`). */
+    href: string;
+    /** Visually and semantically disable the link. */
+    disabled?: boolean;
+}
+/**
+ * EffectButton — the glossy, springy pill ported frame-for-frame from Photon's
+ * Framer "Button - Effect", driven by Motion. `variant="secondary"` swaps the
+ * brand fill for the neutral white-card surface without the sheen (the login /
+ * OAuth pill), and `fullWidth` stretches the pill across its container.
+ * Triggers an action; for navigation use {@link EffectButtonLink}.
+ */
+export declare function EffectButton({ variant, size, fullWidth, prefix, suffix, svgOnly, loading, children, className, ref, ...props }: EffectButtonProps): import("react").JSX.Element;
+export declare namespace EffectButton {
+    var displayName: string;
+}
+/**
+ * EffectButtonLink — {@link EffectButton} as a link, for navigation that changes
+ * the URL. Renders the host router's link (via `LinkProvider`) wrapped by Motion,
+ * so the pill animates identically to the button.
+ */
+export declare function EffectButtonLink({ variant, size, fullWidth, prefix, suffix, svgOnly, loading, disabled, href, children, className, ...props }: EffectButtonLinkProps): import("react").JSX.Element;
+export declare namespace EffectButtonLink {
+    var displayName: string;
+}
+export {};

package/dist/src/components/button/close-button.d.ts

@@ -0,0 +1,28 @@
+import { ButtonHTMLAttributes } from 'react';
+declare const CLOSE_SIZES: {
+    sm: {
+        classes: string;
+    };
+    md: {
+        classes: string;
+    };
+    lg: {
+        classes: string;
+    };
+};
+export interface CloseButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "color"> {
+    /** Size variant. @default "sm" */
+    size?: keyof typeof CLOSE_SIZES;
+    /** Accessible label. @default "Close" */
+    label?: string;
+}
+/**
+ * Icon-only dismiss control — a squircle chip that fills on hover. Adapts to
+ * light/dark automatically via semantic tokens. Used by Dialog and dismissible
+ * surfaces.
+ */
+export declare function CloseButton({ size, label, className, ...props }: CloseButtonProps): import("react").JSX.Element;
+export declare namespace CloseButton {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export { Button, ButtonLink, buttonVariants, BUTTON_SIZES, BUTTON_SHAPES, BUTTON_VARIANTS, EffectButton, EffectButtonLink, effectButtonVariants, EFFECT_BUTTON_SIZES, EFFECT_BUTTON_VARIANTS, type ButtonProps, type ButtonLinkProps, type ButtonSize, type ButtonShape, type ButtonVariant, type EffectButtonProps, type EffectButtonLinkProps, type EffectButtonSize, type EffectButtonVariant, } from './button';
+export { CloseButton, type CloseButtonProps } from './close-button';

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

@@ -0,0 +1,15 @@
+import { ComponentProps } from 'react';
+import { CheckboxGroup as BaseCheckboxGroup } from '@base-ui/react/checkbox-group';
+export interface CheckboxGroupProps extends Omit<ComponentProps<typeof BaseCheckboxGroup>, "className"> {
+    className?: string;
+}
+/**
+ * Groups related `Checkbox`es and tracks their values as one. Built on Base UI
+ * `CheckboxGroup` — supports a parent "select all" checkbox via `allValues`.
+ * Control with `value` / `onValueChange` or leave uncontrolled with
+ * `defaultValue`.
+ */
+export declare function CheckboxGroup({ className, ...props }: CheckboxGroupProps): import("react").JSX.Element;
+export declare namespace CheckboxGroup {
+    var displayName: string;
+}

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

@@ -0,0 +1,20 @@
+import { ComponentProps, ReactNode } from 'react';
+import { Checkbox as BaseCheckbox } from '@base-ui/react/checkbox';
+export type CheckboxSize = "sm" | "md";
+export interface CheckboxProps extends Omit<ComponentProps<typeof BaseCheckbox.Root>, "className"> {
+    className?: string;
+    /** Text rendered beside the box; the whole row toggles the checkbox. */
+    label?: ReactNode;
+    /** Size variant. @default "md" */
+    size?: CheckboxSize;
+}
+/**
+ * Checkbox built on Base UI `Checkbox`. Supports checked, unchecked, and
+ * `indeterminate` states; pass `label` for a clickable text row, or omit it
+ * and provide an `aria-label`. For a set of related options that submit
+ * together, wrap them in `CheckboxGroup`.
+ */
+export declare function Checkbox({ className, label, size, ...props }: CheckboxProps): import("react").JSX.Element;
+export declare namespace Checkbox {
+    var displayName: string;
+}

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

@@ -0,0 +1,2 @@
+export { Checkbox, type CheckboxProps, type CheckboxSize } from './checkbox';
+export { CheckboxGroup, type CheckboxGroupProps } from './checkbox-group';

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

@@ -0,0 +1,20 @@
+import { ComponentProps, ElementType } from 'react';
+import { Collapsible as BaseCollapsible } from '@base-ui/react/collapsible';
+/** 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 BaseCollapsible.Trigger>): import("react").JSX.Element;
+declare function Panel({ className, ...props }: StyledProps<typeof BaseCollapsible.Panel>): import("react").JSX.Element;
+/**
+ * Show/hide a region of content, built on Base UI `Collapsible` with a smooth
+ * height animation. Control with `open` / `onOpenChange` or leave uncontrolled
+ * via `defaultOpen`. For several sections where one expands at a time, use
+ * `Accordion`.
+ */
+export declare const Collapsible: {
+    Root: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').CollapsibleRootProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Trigger: typeof Trigger;
+    Panel: typeof Panel;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Collapsible } from './collapsible';

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

@@ -0,0 +1,49 @@
+import { ComponentProps, ElementType } from 'react';
+import { Combobox as BaseCombobox } from '@base-ui/react/combobox';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function InputGroup({ className, ...props }: StyledProps<typeof BaseCombobox.InputGroup>): import("react").JSX.Element;
+declare function Input({ className, ...props }: StyledProps<typeof BaseCombobox.Input>): import("react").JSX.Element;
+declare function Clear({ className, ...props }: StyledProps<typeof BaseCombobox.Clear>): import("react").JSX.Element;
+declare function Trigger({ className, ...props }: StyledProps<typeof BaseCombobox.Trigger>): import("react").JSX.Element;
+declare function Positioner({ className, sideOffset, ...props }: StyledProps<typeof BaseCombobox.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseCombobox.Popup>): import("react").JSX.Element;
+declare function List({ className, ...props }: StyledProps<typeof BaseCombobox.List>): import("react").JSX.Element;
+declare function Empty({ className, ...props }: StyledProps<typeof BaseCombobox.Empty>): import("react").JSX.Element;
+declare function Item({ className, ...props }: StyledProps<typeof BaseCombobox.Item>): import("react").JSX.Element;
+declare function ItemIndicator({ className, ...props }: StyledProps<typeof BaseCombobox.ItemIndicator>): import("react").JSX.Element;
+declare function GroupLabel({ className, ...props }: StyledProps<typeof BaseCombobox.GroupLabel>): import("react").JSX.Element;
+declare function Chips({ className, ...props }: StyledProps<typeof BaseCombobox.Chips>): import("react").JSX.Element;
+declare function Chip({ className, ...props }: StyledProps<typeof BaseCombobox.Chip>): import("react").JSX.Element;
+declare function ChipRemove({ className, ...props }: StyledProps<typeof BaseCombobox.ChipRemove>): import("react").JSX.Element;
+/**
+ * Combobox built on Base UI `Combobox` — a text input that filters a list as
+ * you type and commits to a value from it. Pass `items` to `Combobox.Root`;
+ * `Combobox.List` takes a render function mapping each (filtered) item to a
+ * `Combobox.Item`. Add `Combobox.Chips` for multi-select. For free-form text
+ * with suggestions, use `Autocomplete`; for a small fixed set, use `Select`.
+ */
+export declare const Combobox: {
+    Root: typeof BaseCombobox.Root;
+    Value: typeof BaseCombobox.Value;
+    InputGroup: typeof InputGroup;
+    Input: typeof Input;
+    Trigger: typeof Trigger;
+    Clear: typeof Clear;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').AutocompletePortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+    List: typeof List;
+    Collection: typeof BaseCombobox.Collection;
+    Empty: typeof Empty;
+    Item: typeof Item;
+    ItemIndicator: typeof ItemIndicator;
+    Group: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').AutocompleteGroupProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof GroupLabel;
+    Chips: typeof Chips;
+    Chip: typeof Chip;
+    ChipRemove: typeof ChipRemove;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Combobox } from './combobox';

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

@@ -0,0 +1,34 @@
+import { ComponentProps, ElementType } from 'react';
+import { ContextMenu as BaseContextMenu } from '@base-ui/react/context-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;
+};
+declare function Positioner({ className, ...props }: StyledProps<typeof BaseContextMenu.Positioner>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseContextMenu.Popup>): import("react").JSX.Element;
+declare function Item({ className, ...props }: StyledProps<typeof BaseContextMenu.Item>): import("react").JSX.Element;
+declare function GroupLabel({ className, ...props }: StyledProps<typeof BaseContextMenu.GroupLabel>): import("react").JSX.Element;
+declare function Separator({ className, ...props }: StyledProps<typeof BaseSeparator>): import("react").JSX.Element;
+declare function SubmenuTrigger({ className, ...props }: StyledProps<typeof BaseContextMenu.SubmenuTrigger>): import("react").JSX.Element;
+/**
+ * Right-click (context) menu built on Base UI `ContextMenu`. `ContextMenu.Trigger`
+ * wraps the area that opens the menu on right-click / long-press; the popup
+ * shares its look with `Menu`. Always mirror these actions somewhere visible —
+ * a context menu must not be the only way to reach them.
+ */
+export declare const ContextMenu: {
+    Root: typeof BaseContextMenu.Root;
+    Trigger: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuTriggerProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Positioner: typeof Positioner;
+    Popup: typeof Popup;
+    Item: typeof Item;
+    Group: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').ContextMenuGroupProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    GroupLabel: typeof GroupLabel;
+    Separator: typeof Separator;
+    SubmenuRoot: typeof BaseContextMenu.SubmenuRoot;
+    SubmenuTrigger: typeof SubmenuTrigger;
+    RadioGroup: import('react').NamedExoticComponent<Omit<import('@base-ui/react').ContextMenuRadioGroupProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+};
+export {};

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

@@ -0,0 +1 @@
+export { ContextMenu } from './context-menu';

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

@@ -0,0 +1,41 @@
+import { ComponentProps, ElementType, ReactNode } from 'react';
+import { Dialog as BaseDialog } from '@base-ui/react/dialog';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Backdrop({ className, ...props }: StyledProps<typeof BaseDialog.Backdrop>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseDialog.Popup>): import("react").JSX.Element;
+declare function Title({ className, ...props }: StyledProps<typeof BaseDialog.Title>): import("react").JSX.Element;
+declare function Description({ className, ...props }: StyledProps<typeof BaseDialog.Description>): import("react").JSX.Element;
+interface ContentProps extends Omit<StyledProps<typeof BaseDialog.Popup>, "title"> {
+    /** Heading rendered in the panel header. */
+    title?: ReactNode;
+    /** Supporting text under the title. */
+    description?: ReactNode;
+    /** Show the top-right close button. @default true */
+    showClose?: boolean;
+    children?: ReactNode;
+}
+/**
+ * Convenience panel: renders the portal, backdrop, and styled popup with an
+ * optional header (title/description + close). For full control, compose the
+ * parts directly (`Dialog.Portal` / `Dialog.Backdrop` / `Dialog.Popup`).
+ */
+declare function Content({ title, description, showClose, children, className, ...props }: ContentProps): import("react").JSX.Element;
+/**
+ * Modal dialog built on Base UI `Dialog`. Controlled or uncontrolled via
+ * `Dialog.Root` (`open` / `onOpenChange` / `defaultOpen`).
+ */
+export declare const Dialog: {
+    Root: typeof BaseDialog.Root;
+    Trigger: BaseDialog.Trigger;
+    Portal: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogPortalProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Backdrop: typeof Backdrop;
+    Popup: typeof Popup;
+    Title: typeof Title;
+    Description: typeof Description;
+    Close: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').AlertDialogCloseProps, "ref"> & import('react').RefAttributes<HTMLButtonElement>>;
+    Content: typeof Content;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Dialog } from './dialog';

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

@@ -0,0 +1,32 @@
+import { ComponentProps, ElementType } from 'react';
+import { Drawer as BaseDrawer } from '@base-ui/react/drawer';
+/** Override Base UI's `string | (state) => string` className with plain string. */
+type StyledProps<T extends ElementType> = Omit<ComponentProps<T>, "className"> & {
+    className?: string;
+};
+declare function Backdrop({ className, ...props }: StyledProps<typeof BaseDrawer.Backdrop>): import("react").JSX.Element;
+declare function Viewport({ className, ...props }: StyledProps<typeof BaseDrawer.Viewport>): import("react").JSX.Element;
+declare function Popup({ className, ...props }: StyledProps<typeof BaseDrawer.Popup>): import("react").JSX.Element;
+declare function Content({ className, ...props }: StyledProps<typeof BaseDrawer.Content>): import("react").JSX.Element;
+declare function Title({ className, ...props }: StyledProps<typeof BaseDrawer.Title>): import("react").JSX.Element;
+declare function Description({ className, ...props }: StyledProps<typeof BaseDrawer.Description>): import("react").JSX.Element;
+/**
+ * Drawer built on Base UI `Drawer` — a panel that slides in from the edge
+ * (here, the right) with swipe-to-dismiss. Use it for secondary tasks and
+ * navigation that should keep page context; for a forced decision use
+ * `AlertDialog`, and for a centered modal use `Dialog`. Compose `Drawer.Portal`
+ * → `Backdrop` → `Viewport` → `Popup` → `Content`.
+ */
+export declare const Drawer: {
+    Root: typeof BaseDrawer.Root;
+    Trigger: BaseDrawer.Trigger;
+    Portal: BaseDrawer.Portal;
+    Backdrop: typeof Backdrop;
+    Viewport: typeof Viewport;
+    Popup: typeof Popup;
+    Content: typeof Content;
+    Title: typeof Title;
+    Description: typeof Description;
+    Close: BaseDrawer.Close;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Drawer } from './drawer';

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

@@ -0,0 +1,27 @@
+import { ComponentProps, ElementType } from 'react';
+import { Field as BaseField } from '@base-ui/react/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 BaseField.Root>): import("react").JSX.Element;
+declare function Label({ className, ...props }: StyledProps<typeof BaseField.Label>): import("react").JSX.Element;
+declare function Control({ className, ...props }: StyledProps<typeof BaseField.Control>): import("react").JSX.Element;
+declare function Description({ className, ...props }: StyledProps<typeof BaseField.Description>): import("react").JSX.Element;
+declare function Error({ className, ...props }: StyledProps<typeof BaseField.Error>): import("react").JSX.Element;
+/**
+ * Form field built on Base UI `Field`. Wires a label, description, and
+ * validation error to a control for you — compose it around `Field.Control`
+ * (or any control via `render`). `Field.Error` shows when the control is
+ * invalid; `Field.Validity` exposes raw validity for custom messages.
+ */
+export declare const Field: {
+    Root: typeof Root;
+    Label: typeof Label;
+    Control: typeof Control;
+    Description: typeof Description;
+    Error: typeof Error;
+    Item: import('react').ForwardRefExoticComponent<Omit<import('@base-ui/react').FieldItemProps, "ref"> & import('react').RefAttributes<HTMLDivElement>>;
+    Validity: import('react').FC<import('@base-ui/react').FieldValidityProps>;
+};
+export {};

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

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

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

@@ -0,0 +1,18 @@
+import { ComponentProps, ElementType } from 'react';
+import { Fieldset as BaseFieldset } from '@base-ui/react/fieldset';
+/** 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 BaseFieldset.Root>): import("react").JSX.Element;
+declare function Legend({ className, ...props }: StyledProps<typeof BaseFieldset.Legend>): import("react").JSX.Element;
+/**
+ * Groups related fields under a shared legend, built on Base UI `Fieldset`.
+ * Use it to title a cluster of inputs (e.g. "Billing address") so the grouping
+ * is announced to assistive tech.
+ */
+export declare const Fieldset: {
+    Root: typeof Root;
+    Legend: typeof Legend;
+};
+export {};

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

@@ -0,0 +1 @@
+export { Fieldset } from './fieldset';

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

@@ -0,0 +1,14 @@
+import { ComponentProps } from 'react';
+import { Form as BaseForm } from '@base-ui/react/form';
+export interface FormProps extends Omit<ComponentProps<typeof BaseForm>, "className"> {
+    className?: string;
+}
+/**
+ * Form wrapper built on Base UI `Form`. Coordinates the contained `Field`s —
+ * pass server-side `errors` and they surface on the matching fields, and
+ * `onClearErrors` clears them as the user edits.
+ */
+export declare function Form({ className, ...props }: FormProps): import("react").JSX.Element;
+export declare namespace Form {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { Form, type FormProps } from './form';

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

@@ -0,0 +1 @@
+export { Input, type InputProps, type InputSize } from './input';

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

@@ -0,0 +1,30 @@
+import { ComponentType, InputHTMLAttributes, ReactNode, Ref } from 'react';
+export type InputSize = "sm" | "md" | "lg";
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    /** Field label (associated for accessibility). */
+    label?: ReactNode;
+    /** Helper text below the field; rendered in the error color when `invalid`. */
+    hint?: ReactNode;
+    /** Size variant. @default "md" */
+    size?: InputSize;
+    /** Render the invalid state (ring + icon + error-colored hint). */
+    invalid?: boolean;
+    /** Leading icon component (e.g. a Phosphor icon). */
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Node rendered at the right edge of the label row (e.g. "Forgot?"). */
+    labelTrailing?: ReactNode;
+    /** Class applied to the input wrapper. */
+    wrapperClassName?: string;
+    ref?: Ref<HTMLInputElement>;
+}
+/**
+ * Text input built on Base UI `Field` (label/description a11y wiring) with
+ * Pho's bordered surface, leading icon, invalid state, and a built-in password
+ * reveal toggle.
+ */
+export declare function Input({ label, hint, size, invalid, icon: Icon, labelTrailing, disabled, required, type, className, wrapperClassName, id, ref, ...props }: InputProps): import("react").JSX.Element;
+export declare namespace Input {
+    var displayName: string;
+}

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

@@ -0,0 +1 @@
+export { Kbd, type KbdProps } from './kbd';

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

@@ -0,0 +1,18 @@
+import { ComponentProps } from 'react';
+interface KbdBaseProps {
+    /** Convenience string for the key(s) to show, e.g. "⌘K". Ignored when `children` are provided. */
+    keys?: string;
+}
+export interface KbdProps extends KbdBaseProps, Omit<ComponentProps<"kbd">, keyof KbdBaseProps> {
+}
+/**
+ * Kbd — a keyboard keycap for documenting a shortcut (`⌘K`, `Esc`, `↵`). Supply
+ * the key via `children` or the `keys` string; for a chord, place several in a
+ * row (`Press ⌘ K`). It's purely presentational and carries no interaction — to
+ * actually trigger a shortcut, wire a key handler on the target control.
+ */
+export declare function Kbd({ keys, className, children, ...props }: KbdProps): import("react").JSX.Element;
+export declare namespace Kbd {
+    var displayName: string;
+}
+export {};

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

@@ -0,0 +1 @@
+export { Menu, MENU_POPUP, MENU_ITEM } from './menu';