sherick-ui 2.0.0 → 2.1.0

package/dist/types/index.d.cts

@@ -1,18 +1,20 @@
 import { Accordion as Accordion$1 } from '@base-ui/react/accordion';
-import React, { ReactNode, ButtonHTMLAttributes, ImgHTMLAttributes, HTMLAttributes, Ref, ComponentProps, InputHTMLAttributes, ComponentPropsWithoutRef, ForwardRefExoticComponent, RefAttributes, ReactElement, MouseEventHandler, AnchorHTMLAttributes, TextareaHTMLAttributes } from 'react';
+import * as React from 'react';
+import React__default, { ReactNode, ButtonHTMLAttributes, ImgHTMLAttributes, HTMLAttributes, ComponentPropsWithoutRef, AnchorHTMLAttributes, ComponentProps, Ref, ReactElement, InputHTMLAttributes, ForwardRefExoticComponent, RefAttributes, MouseEventHandler, ComponentPropsWithRef, TextareaHTMLAttributes } from 'react';
 import { Collapsible as Collapsible$1 } from '@base-ui/react/collapsible';
 import { AlertDialog as AlertDialog$1 } from '@base-ui/react/alert-dialog';
 import { Checkbox as Checkbox$1 } from '@base-ui/react/checkbox';
 import { Toggle } from '@base-ui/react/toggle';
 import { ToggleGroup as ToggleGroup$1 } from '@base-ui/react/toggle-group';
 import { Combobox as Combobox$1 } from '@base-ui/react/combobox';
+import { Autocomplete } from '@base-ui/react/autocomplete';
+import { Dialog as Dialog$1 } from '@base-ui/react/dialog';
+import { Popover as Popover$1 } from '@base-ui/react/popover';
 import { Select as Select$1 } from '@base-ui/react/select';
 import { Field as Field$1 } from '@base-ui/react/field';
 import { Input as Input$1 } from '@base-ui/react/input';
-import { Dialog as Dialog$1 } from '@base-ui/react/dialog';
 import { Menu as Menu$1 } from '@base-ui/react/menu';
 import { NumberField as NumberField$1 } from '@base-ui/react/number-field';
-import { Popover as Popover$1 } from '@base-ui/react/popover';
 import { Progress as Progress$1 } from '@base-ui/react/progress';
 import { RadioGroup as RadioGroup$1 } from '@base-ui/react/radio-group';
 import { Slider as Slider$1 } from '@base-ui/react/slider';
@@ -67,14 +69,14 @@ interface AccordionPanelProps {
     /** Adds to the measured region. The region's height and clipping are the recipe's. */
     className?: string;
 }
-declare const AccordionItem: ({ children, className, ...props }: AccordionItemProps) => React.JSX.Element;
-type AccordionComponent = ((props: AccordionProps) => React.JSX.Element) & {
+declare const AccordionItem: ({ children, className, ...props }: AccordionItemProps) => React__default.JSX.Element;
+type AccordionComponent = ((props: AccordionProps) => React__default.JSX.Element) & {
     Item: typeof AccordionItem;
     Trigger: typeof AccordionTrigger;
     Panel: typeof AccordionPanel;
 };
-declare const AccordionTrigger: ({ children, className }: AccordionTriggerProps) => React.JSX.Element;
-declare const AccordionPanel: ({ children, className }: AccordionPanelProps) => React.JSX.Element;
+declare const AccordionTrigger: ({ children, className }: AccordionTriggerProps) => React__default.JSX.Element;
+declare const AccordionPanel: ({ children, className }: AccordionPanelProps) => React__default.JSX.Element;
 declare const Accordion: AccordionComponent;
 
 interface CollapsibleProps {
@@ -100,12 +102,12 @@ interface CollapsiblePanelProps {
     /** Adds to the measured region. The region's height and clipping are the recipe's. */
     className?: string;
 }
-type CollapsibleComponent = ((props: CollapsibleProps) => React.JSX.Element) & {
+type CollapsibleComponent = ((props: CollapsibleProps) => React__default.JSX.Element) & {
     Trigger: typeof CollapsibleTrigger;
     Panel: typeof CollapsiblePanel;
 };
-declare const CollapsibleTrigger: ({ children, className }: CollapsibleTriggerProps) => React.JSX.Element;
-declare const CollapsiblePanel: ({ children, className }: CollapsiblePanelProps) => React.JSX.Element;
+declare const CollapsibleTrigger: ({ children, className }: CollapsibleTriggerProps) => React__default.JSX.Element;
+declare const CollapsiblePanel: ({ children, className }: CollapsiblePanelProps) => React__default.JSX.Element;
 /**
  * One region that expands where it sits, without belonging to a group. Base UI owns the expanded
  * state and the trigger's `aria-expanded`/`aria-controls` plumbing — including making the
@@ -139,7 +141,7 @@ interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     icon?: ReactNode;
     loading?: boolean;
 }
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 interface AlertProps {
     children: ReactNode;
@@ -148,7 +150,7 @@ interface AlertProps {
     closeable?: boolean;
     onDismiss?: () => void;
 }
-declare const Alert: ({ children, variant, className, closeable, onDismiss, }: AlertProps) => React.JSX.Element | null;
+declare const Alert: ({ children, variant, className, closeable, onDismiss, }: AlertProps) => React__default.JSX.Element | null;
 
 interface AlertDialogProps {
     /** The question the dialog asks. Base makes it the surface's accessible name. */
@@ -183,7 +185,7 @@ interface AlertDialogProps {
  * anything. Base owns presence, focus restoration, Escape and the `alertdialog` semantics; the
  * surface, typography and shape are the same ones `Dialog` uses.
  */
-declare const AlertDialog: React.ForwardRefExoticComponent<AlertDialogProps & React.RefAttributes<HTMLDivElement>>;
+declare const AlertDialog: React__default.ForwardRefExoticComponent<AlertDialogProps & React__default.RefAttributes<HTMLDivElement>>;
 
 interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src" | "alt" | "width" | "height"> {
     src: string;
@@ -191,20 +193,115 @@ interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src" |
     size?: "sm" | "md" | "lg";
     shape?: "circle" | "rounded";
 }
-declare const Avatar: ({ src, alt, size, shape: shapeRole, className, ...props }: AvatarProps) => React.JSX.Element;
+declare const Avatar: ({ src, alt, size, shape: shapeRole, className, ...props }: AvatarProps) => React__default.JSX.Element;
 
 interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
     children: ReactNode;
     variant?: Variant;
     icon?: ReactNode;
 }
-declare const Badge: ({ children, variant, icon, className, ...props }: BadgeProps) => React.JSX.Element;
+declare const Badge: ({ children, variant, icon, className, ...props }: BadgeProps) => React__default.JSX.Element;
+
+interface BreadcrumbItem {
+    label: ReactNode;
+    href?: string;
+}
+interface BreadcrumbProps extends Omit<ComponentPropsWithoutRef<"nav">, "children"> {
+    items: BreadcrumbItem[];
+    /**
+     * How an intermediate destination is rendered — the escape hatch for a router link. The supplied
+     * props carry the destination, the shared classes and the item's own content, and the renderer
+     * spreads them onto its element.
+     */
+    renderLink?: (item: BreadcrumbItem, props: AnchorHTMLAttributes<HTMLAnchorElement>) => ReactNode;
+}
+declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
+
+type CalendarDate = string;
+interface DateRange {
+    start: CalendarDate | null;
+    end: CalendarDate | null;
+}
+interface CalendarLabels {
+    /** The control that moves the grid to the previous month. */
+    previousMonth: string;
+    /** The control that moves the grid to the next month. */
+    nextMonth: string;
+    /** The control that navigates to today without selecting it. */
+    today: string;
+    /** Describes a single-date grid to assistive technology. */
+    selectDate: string;
+    /** Describes a range grid to assistive technology. */
+    selectRange: string;
+    /** Reported when a date — or a range — cannot be selected or is not acceptable. */
+    unavailableRange: string;
+}
+
+interface CalendarBaseProps extends Omit<ComponentProps<"div">, "children" | "value" | "defaultValue" | "defaultChecked" | "onChange"> {
+    /** The month on screen, normalized to its first day. Undefined means the calendar owns it. */
+    month?: CalendarDate;
+    defaultMonth?: CalendarDate;
+    /** Receives the month the grid moved to, as a date normalized to its first day. */
+    onMonthChange?: (month: CalendarDate) => void;
+    /** The earliest selectable date, inclusive. */
+    min?: CalendarDate;
+    /** The latest selectable date, inclusive. */
+    max?: CalendarDate;
+    /**
+     * Whether a date cannot be chosen. Unavailable dates stay visible, focusable and announced as
+     * disabled; they are simply never selected, and a range may not span one.
+     */
+    isDateUnavailable?: (date: CalendarDate) => boolean;
+    disabled?: boolean;
+    /** Marks the calendar's own value as not acceptable; the selection wears the danger tone. */
+    invalid?: boolean;
+    /** A BCP 47 tag. It changes how the grid writes and announces dates, never what they mean. */
+    locale?: string;
+    /** Which weekday a row starts on: 0 is Sunday. */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** The civil day this application calls today; defaults to the current UTC day. */
+    today?: CalendarDate;
+    labels?: Partial<CalendarLabels>;
+}
+interface CalendarSingleProps extends CalendarBaseProps {
+    mode?: "single";
+    value?: CalendarDate | null;
+    defaultValue?: CalendarDate | null;
+    onValueChange?: (value: CalendarDate | null) => void;
+}
+interface CalendarRangeProps extends CalendarBaseProps {
+    mode: "range";
+    value?: DateRange | null;
+    defaultValue?: DateRange | null;
+    onValueChange?: (value: DateRange) => void;
+}
+/** A single-date grid, or a range grid whose selection is a pair of endpoints. */
+type CalendarProps = CalendarSingleProps | CalendarRangeProps;
+/**
+ * One month of a Gregorian calendar, navigated as a keyboard grid.
+ *
+ * The grid follows the APG date-picker model: a `grid` of `gridcolumnheader` and `gridcell`
+ * elements, exactly one tabbable day, `aria-selected` on the selected cells and `aria-current`
+ * on today. Arrow keys move by day and week, Home and End move within the row, PageUp and
+ * PageDown move a month, and Shift with them moves a year; every one of those retains a real
+ * day under focus, so the grid can be crossed by keyboard alone. The horizontal arrows mirror in
+ * a right-to-left page, because the reader's "next day" is the direction the text runs in.
+ *
+ * Days outside `min` and `max`, or refused by `isDateUnavailable`, stay in the grid — they are
+ * discoverable, focusable and announced as disabled — and selection is refused on them. A range
+ * may not span one either: an endpoint that would complete such a range is refused and the
+ * reason is announced, because a completed range must describe dates the application can accept.
+ *
+ * Values are `YYYY-MM-DD` civil dates and carry no time; every step the grid takes is calendar
+ * arithmetic, so a month crossing, a leap day and a year boundary are all exact.
+ */
+declare const Calendar: React__default.ForwardRefExoticComponent<(Omit<CalendarSingleProps, "ref"> | Omit<CalendarRangeProps, "ref">) & React__default.RefAttributes<HTMLDivElement>>;
 
 interface CardProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
     variant?: Variant;
 }
-declare const Card: ({ children, variant, className, ...props }: CardProps) => React.JSX.Element;
+declare const Card: ({ children, variant, className, ...props }: CardProps) => React__default.JSX.Element;
 
 interface CheckboxProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "type"> {
     checked?: boolean;
@@ -224,7 +321,7 @@ interface CheckboxProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "v
  * A ticked, unticked or mixed choice. The ref points at the visible button; the form input Base
  * UI keeps beside it is reached through `inputRef`.
  */
-declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 /** The parts every chip has, whichever of its two forms it takes. */
 interface ChipAnatomy {
@@ -281,7 +378,7 @@ type ChipProps = (ChipAnatomy & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "v
  * its normal emphasis while its icon carries the semantic tone, and its only control is the dismiss
  * one. The ref points at the chip's own element — the button or the tag's span.
  */
-declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLElement>>;
+declare const Chip: React__default.ForwardRefExoticComponent<ChipProps & React__default.RefAttributes<HTMLElement>>;
 
 interface ChipGroupProps extends Omit<ToggleGroup$1.Props<string>, "multiple" | "className" | "render"> {
     children: ReactNode;
@@ -302,7 +399,7 @@ interface ChipGroupProps extends Omit<ToggleGroup$1.Props<string>, "multiple" |
  * A tag inside the group is not a toggle, so it takes no part in the shared value and no part in
  * the roving focus; its dismiss control is reachable by Tab like any other control.
  */
-declare const ChipGroup: React.ForwardRefExoticComponent<Omit<ChipGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ChipGroup: React__default.ForwardRefExoticComponent<Omit<ChipGroupProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
 interface ComboboxOption {
     label: string;
@@ -359,7 +456,223 @@ interface ComboboxProps {
  * Filtering is Base's and it is local — an application that needs remote results owns the
  * fetching, the debounce and the loading state around this control.
  */
-declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLInputElement>>;
+declare const Combobox: React__default.ForwardRefExoticComponent<ComboboxProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface CommandItem {
+    /** The action's own identity. Values are unique across the list. */
+    value: string;
+    /** What a reader scans, and what the default matching searches. */
+    label: string;
+    /**
+     * An action that cannot be performed. It stays in the list and stays reachable by keyboard —
+     * a command that cannot run is still one a reader has to be able to find and be told about —
+     * but it cannot activate, and it takes no hover or press state.
+     */
+    disabled?: boolean;
+    /** The group this command is listed under. Commands without one keep a group of their own. */
+    group?: string;
+    /**
+     * Metadata beside the label: the gesture that runs this command elsewhere. It is a hint rather
+     * than a registered shortcut, and this control owns no keyboard manager.
+     */
+    shortcut?: ReactNode;
+    /** Metadata: the row's leading mark. */
+    icon?: ReactNode;
+    /** Extra terms the default matching searches beside the label. */
+    keywords?: string[];
+}
+type AutocompleteRootProps = Autocomplete.Root.Props<CommandItem>;
+type CommandQueryChangeDetails = Parameters<NonNullable<AutocompleteRootProps["onValueChange"]>>[1];
+interface CommandProps {
+    items: CommandItem[];
+    /**
+     * Names the search field for assistive technology. It is the field's own name — a palette's
+     * heading names the surface — so it is not rendered as visible copy.
+     */
+    label: string;
+    /**
+     * What choosing a command does. A command performs an action rather than holding a value, so
+     * this is the next domain value rather than an event, and activating one leaves the query and
+     * the list exactly as they were.
+     */
+    onAction?: (value: string) => void;
+    /** The query, when the application controls it. */
+    value?: string;
+    /** The query a fresh control starts with. Undefined means uncontrolled. */
+    defaultValue?: string;
+    /** Base's own query-change callback, event details included. */
+    onValueChange?: (value: string, eventDetails: CommandQueryChangeDetails) => void;
+    placeholder?: string;
+    /** Shown in place of the list when the query matches no command. */
+    emptyMessage?: ReactNode;
+    disabled?: boolean;
+    /** A string comparison locale for the default matching. */
+    locale?: string;
+    /**
+     * Custom matching, or `null` to list every command whatever the query. The item is the caller's
+     * own `CommandItem`, so the callback matches on the data rather than on anything rendered.
+     */
+    filter?: ((item: CommandItem, query: string) => boolean) | null;
+    /** Adds to the control's own column. */
+    className?: string;
+    /** Adds to the search field itself. */
+    inputClassName?: string;
+    /** The search field's own id, for a caller's native `<label htmlFor>`. */
+    id?: string;
+    /**
+     * The command's own content, in place of its label. It is non-interactive content: the row
+     * itself is the control, and a nested action would be a second target inside one.
+     */
+    renderItem?: (item: CommandItem) => ReactNode;
+}
+/**
+ * A command list: a search field and the commands it filters, both inline on the surface they
+ * belong to. Base UI owns the filtering, the highlight, the active-descendant wiring, the keyboard
+ * navigation, the collection and its groups, the empty region and the scroll behaviour; Sherick UI
+ * owns the field, the sheet, the row treatment and the one thing a command adds to a listbox — an
+ * activation that performs an action and leaves the query alone.
+ *
+ * The list is deliberately never a popup. `Select` holds a value and `Combobox` chooses one, so
+ * both open a list that dismisses; a command list stays where it is, which is what makes a command
+ * repeatable without reopening anything.
+ */
+declare const Command: React__default.ForwardRefExoticComponent<CommandProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface CommandPaletteProps extends Omit<CommandProps, "className" | "id"> {
+    /** The surface's own heading. It names the dialog. */
+    title: string;
+    /** Supporting copy beneath the heading, when the surface needs it. */
+    description?: ReactNode;
+    /**
+     * The element the trigger's own props are handed to — usually a Sherick `Button`. The palette
+     * opens from whatever this renders, so the control that opens it looks like the control it is.
+     */
+    trigger?: ReactElement;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Base's own open-change callback, event details included. */
+    onOpenChange?: Dialog$1.Root.Props["onOpenChange"];
+    /** Adds to the dialog surface's own shell. */
+    className?: string;
+}
+/**
+ * The same command list as a surface that owns the viewport: a palette. It is a `Dialog` — Base's
+ * dialog root, the shared `DialogSurface` and dismissal, with a compact command header — with one
+ * difference: the surface exists to be typed into, so the search field takes the initial focus and
+ * the commands are the answer to what was typed.
+ *
+ * The palette keeps no open state of its own. Base owns modality, the portal, the focus trap, the
+ * first-Escape dismissal and the restoration; the action reports what ran and the primitive's own
+ * `actionsRef.close()` dismisses the surface, which is also what resets an uncontrolled query —
+ * the control unmounts with the popup it was rendered in.
+ *
+ * It composes Base's dialog root and the shared surface rather than the `Dialog` component, because
+ * the two things a palette adds are both contracts of the surface: the search field is the initial
+ * focus, and a run command closes the surface through Base's own actions instead of through an
+ * open state kept here.
+ */
+declare const CommandPalette: React__default.ForwardRefExoticComponent<CommandPaletteProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface DatePickerProps {
+    /** The selected date, or `null` for no selection. Undefined makes the picker uncontrolled. */
+    value?: CalendarDate | null;
+    defaultValue?: CalendarDate | null;
+    /** Receives the next date, or `null` when the field is cleared. */
+    onValueChange?: (value: CalendarDate | null) => void;
+    /** The field's label. It names the native field, its control and the calendar popup. */
+    label: string;
+    description?: ReactNode;
+    error?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    /** Styles the field's own column. */
+    className?: string;
+    id?: string;
+    /** The form that owns the field, when it renders outside it. */
+    form?: string;
+    /** Identifies the field when it is submitted. */
+    name?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Base's own open-change callback, event details included. */
+    onOpenChange?: Popover$1.Root.Props["onOpenChange"];
+    /** The earliest acceptable date, inclusive. */
+    min?: CalendarDate;
+    /** The latest acceptable date, inclusive. */
+    max?: CalendarDate;
+    /** Whether a date cannot be chosen. Unavailable dates stay visible and are never selected. */
+    isDateUnavailable?: (date: CalendarDate) => boolean;
+    locale?: string;
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    today?: CalendarDate;
+    labels?: Partial<CalendarLabels>;
+}
+/**
+ * A date field: a native `type=date` input, with a named control beside it that opens the shared
+ * `Calendar` in a popover.
+ *
+ * The native input stays the field's control, so the browser owns its entry, its mobile UI, its
+ * form submission and the `required` and `min`/`max` constraints; `isDateUnavailable` is reported
+ * through the field's own validation, and a date the calendar would refuse is never accepted as a
+ * value — the input keeps what was typed and the field says why. The calendar gives the same
+ * value a grid, a keyboard and a month of context.
+ */
+declare const DatePicker: React__default.ForwardRefExoticComponent<DatePickerProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface DateRangePickerProps {
+    /** The selected range. `{ start: null, end: null }` is an empty selection; a start without an
+     *  end is a range that is still being chosen. Undefined makes the picker uncontrolled. */
+    value?: DateRange | null;
+    defaultValue?: DateRange | null;
+    /** Receives the next range; clearing reports both endpoints as `null`. */
+    onValueChange?: (value: DateRange) => void;
+    /** Names the range group. */
+    label: string;
+    /** The first field's own label. */
+    startLabel?: string;
+    /** The second field's own label. */
+    endLabel?: string;
+    description?: ReactNode;
+    error?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    /** Styles the range group. */
+    className?: string;
+    /** The first field's own id. The second derives its id from it. */
+    id?: string;
+    /** The form that owns the fields, when they render outside it. */
+    form?: string;
+    /** Identifies the range's start when it is submitted. */
+    startName?: string;
+    /** Identifies the range's end when it is submitted. */
+    endName?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Base's own open-change callback, event details included. */
+    onOpenChange?: Popover$1.Root.Props["onOpenChange"];
+    /** The earliest acceptable date, inclusive. */
+    min?: CalendarDate;
+    /** The latest acceptable date, inclusive. */
+    max?: CalendarDate;
+    /** Whether a date cannot be chosen. A range may not span an unavailable date. */
+    isDateUnavailable?: (date: CalendarDate) => boolean;
+    locale?: string;
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    today?: CalendarDate;
+    labels?: Partial<CalendarLabels>;
+}
+/**
+ * A range of dates: two independently labelled native date fields in one named group, and one
+ * calendar they share.
+ *
+ * Each endpoint is the browser's own `type=date` control, so entry, mobile UI, submission and the
+ * `required` and `min`/`max` constraints belong to the platform. The picker's own rule is that a
+ * range which reverses its endpoints or spans a date the application refuses is never accepted:
+ * the typed value stays on screen, the field reports why, and the calendar's selection does not
+ * move. The calendar itself refuses the same spans, so a pointer and a keyboard cannot reach a
+ * range the field would reject.
+ */
+declare const DateRangePicker: React__default.ForwardRefExoticComponent<DateRangePickerProps & React__default.RefAttributes<HTMLInputElement>>;
 
 declare const edgeTone: {
     readonly row: "border-sherick-edge/[0.06]";
@@ -379,7 +692,7 @@ interface DividerProps {
     /** The weight of the line. `rule` is the general section break. */
     weight?: DividerWeight;
 }
-declare const Divider: ({ className, orientation, weight }: DividerProps) => React.JSX.Element;
+declare const Divider: ({ className, orientation, weight }: DividerProps) => React__default.JSX.Element;
 
 interface SelectOption {
     label: string;
@@ -399,7 +712,7 @@ interface SelectProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "val
     readOnly?: boolean;
     required?: boolean;
 }
-declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 interface FieldProps extends Omit<ComponentProps<typeof Field$1.Root>, "children" | "className" | "ref"> {
     /** The field's label. Base UI associates it with the control and names the group. */
@@ -432,7 +745,69 @@ interface FieldProps extends Omit<ComponentProps<typeof Field$1.Root>, "children
  * `aria-describedby` / `aria-invalid` wiring; this component owns only the order and the
  * typography of label, control, description and error.
  */
-declare const Field: React.ForwardRefExoticComponent<FieldProps & React.RefAttributes<HTMLDivElement>>;
+declare const Field: React__default.ForwardRefExoticComponent<FieldProps & React__default.RefAttributes<HTMLDivElement>>;
+
+type RejectionCode = "type" | "size" | "count";
+/** One file a selection operation refused, with the reason it was refused. */
+interface FileRejection {
+    file: File;
+    code: RejectionCode;
+    message: string;
+}
+
+/**
+ * A labelled field that selects files from the native picker or by dropping them on its zone.
+ *
+ * `files` / `defaultFiles` own the *presented* selection. They are deliberately not the picker's
+ * own value: the native input stays uncontrolled and is emptied after every read, so choosing the
+ * same file twice still reports twice, and nothing this component does assigns files to it or
+ * mirrors them into hidden inputs. There is therefore no `name`/`required` submission contract —
+ * a consumer builds `FormData` from `onFilesChange`, which is the one place the selection is
+ * reported.
+ *
+ * The chooser and the drop zone are the same door twice, so they answer to one policy
+ * (`fileUpload.rules.ts`): a file refused by the picker's `accept` value cannot enter through a
+ * drop, and a mixed batch keeps whatever was valid.
+ */
+interface FileUploadProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange" | "defaultValue"> {
+    /** The field's label. It names the picker. */
+    label: string;
+    /** Supporting copy beneath the field. */
+    description?: ReactNode;
+    /**
+     * The message shown while the field is invalid. Its presence is what makes the field invalid,
+     * exactly as `error` does on the other fields in the library.
+     */
+    error?: ReactNode;
+    /** The controlled selection. Undefined leaves the selection to the component. */
+    files?: File[];
+    /** The selection the field starts with when it is not controlled. */
+    defaultFiles?: File[];
+    /**
+     * Reports the selection after every accepted change. The callback receives the next selection as
+     * a whole, which is what a consumer builds `FormData` from.
+     */
+    onFilesChange?: (files: File[]) => void;
+    /** Whether the field holds several files or replaces its selection with one. */
+    multiple?: boolean;
+    /** The native `accept` value: comma-separated MIME types and extensions. A UX restriction only. */
+    accept?: string;
+    /** Per-file byte limit. A larger file is refused and reported. */
+    maxSize?: number;
+    /** Total file limit. Only meaningful with `multiple`. */
+    maxFiles?: number;
+    /** Ignore user interaction. Removes the picker, the drop, the removals and the clear control. */
+    disabled?: boolean;
+    /** Reports the files a batch refused, with the reason for each. */
+    onReject?: (items: FileRejection[]) => void;
+    /** The copy on the zone's own affordance. */
+    selectLabel?: string;
+    /** The accessible name of one removal control. Defaults to `Remove <file name>`. */
+    removeLabel?: (file: File) => string;
+    /** The accessible name of the control that empties the selection. */
+    clearLabel?: string;
+}
+declare const FileUpload: React__default.ForwardRefExoticComponent<FileUploadProps & React__default.RefAttributes<HTMLInputElement>>;
 
 type IconButtonAppearance = "tonal" | "ghost" | "acrylic";
 interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
@@ -441,7 +816,7 @@ interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     icon?: ReactNode;
     loading?: boolean;
 }
-declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const IconButton: React__default.ForwardRefExoticComponent<IconButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
     label?: ReactNode;
@@ -452,25 +827,25 @@ interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
     /** Base's value-change callback, event details included. */
     onValueChange?: Input$1.Props["onValueChange"];
 }
-declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;
 
 type DialogContentProps = HTMLAttributes<HTMLDivElement>;
-declare const DialogContent: ({ children, className, ...props }: DialogContentProps) => React.JSX.Element;
+declare const DialogContent: ({ children, className, ...props }: DialogContentProps) => React__default.JSX.Element;
 
 type DialogDescriptionProps = ComponentPropsWithoutRef<typeof Dialog$1.Description>;
-declare const DialogDescription: ({ className, ...props }: DialogDescriptionProps) => React.JSX.Element;
+declare const DialogDescription: ({ className, ...props }: DialogDescriptionProps) => React__default.JSX.Element;
 
 interface DialogFooterProps {
     children: ReactNode;
     className?: string;
 }
-declare const DialogFooter: ({ children, className }: DialogFooterProps) => React.JSX.Element;
+declare const DialogFooter: ({ children, className }: DialogFooterProps) => React__default.JSX.Element;
 
 interface DialogHeaderProps {
     children: ReactNode;
     className?: string;
 }
-declare const DialogHeader: ({ children, className }: DialogHeaderProps) => React.JSX.Element;
+declare const DialogHeader: ({ children, className }: DialogHeaderProps) => React__default.JSX.Element;
 
 interface DialogProps {
     children: ReactNode;
@@ -546,21 +921,68 @@ interface MenuSeparatorProps {
  * capabilities this package supports, not the primitive's complete prop set. Composing a Base
  * primitive is how these components are built; it is not what they promise.
  */
-type MenuComponent = ((props: MenuProps) => React.JSX.Element) & {
+type MenuComponent = ((props: MenuProps) => React__default.JSX.Element) & {
     Trigger: typeof MenuTrigger;
     Content: typeof MenuContent;
     Item: typeof MenuItem;
     Separator: typeof MenuSeparator;
 };
-declare const MenuContent: ({ children, className, side, align, sideOffset, alignOffset, }: MenuContentProps) => React.JSX.Element;
-declare const MenuTrigger: ({ ...props }: MenuTriggerProps) => React.JSX.Element;
+declare const MenuContent: ({ children, className, side, align, sideOffset, alignOffset, }: MenuContentProps) => React__default.JSX.Element;
+declare const MenuTrigger: ({ ...props }: MenuTriggerProps) => React__default.JSX.Element;
 declare const MenuItem: {
-    ({ variant, className, children, ...props }: MenuItemProps): React.JSX.Element;
+    ({ variant, className, children, ...props }: MenuItemProps): React__default.JSX.Element;
     displayName: string;
 };
-declare const MenuSeparator: ({ className }: MenuSeparatorProps) => React.JSX.Element;
+declare const MenuSeparator: ({ className }: MenuSeparatorProps) => React__default.JSX.Element;
 declare const Menu: MenuComponent;
 
+type Presentation = {
+    aspect?: "auto" | "square" | "portrait" | "landscape" | "video" | "wide";
+    fit?: "cover" | "contain";
+    position?: "center" | "top" | "bottom";
+    radius?: "default" | "none";
+    /** Applied to the frame, not the native media element. */
+    className?: string;
+};
+type MediaImageProps = Presentation & Omit<ComponentPropsWithRef<"img">, keyof Presentation | "alt"> & ({
+    alt: string;
+    decorative?: false;
+} | {
+    decorative: true;
+    alt?: never;
+});
+type MediaVideoProps = Presentation & Omit<ComponentPropsWithRef<"video">, keyof Presentation | "controls" | "tabIndex" | "aria-hidden"> & ({
+    decorative?: false;
+    controls?: boolean;
+    tabIndex?: number;
+    "aria-hidden"?: boolean | "true" | "false";
+} | {
+    decorative: true;
+    controls?: never;
+    tabIndex?: never;
+    "aria-hidden"?: never;
+});
+declare const Media: {
+    Image: React__default.ForwardRefExoticComponent<(Omit<Presentation & Omit<React__default.DetailedHTMLProps<React__default.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "alt" | keyof Presentation> & {
+        alt: string;
+        decorative?: false;
+    }, "ref"> | Omit<Presentation & Omit<React__default.DetailedHTMLProps<React__default.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "alt" | keyof Presentation> & {
+        decorative: true;
+        alt?: never;
+    }, "ref">) & React__default.RefAttributes<HTMLImageElement>>;
+    Video: React__default.ForwardRefExoticComponent<(Omit<Presentation & Omit<React__default.DetailedHTMLProps<React__default.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "tabIndex" | "aria-hidden" | keyof Presentation | "controls"> & {
+        decorative?: false;
+        controls?: boolean;
+        tabIndex?: number;
+        "aria-hidden"?: boolean | "true" | "false";
+    }, "ref"> | Omit<Presentation & Omit<React__default.DetailedHTMLProps<React__default.VideoHTMLAttributes<HTMLVideoElement>, HTMLVideoElement>, "tabIndex" | "aria-hidden" | keyof Presentation | "controls"> & {
+        decorative: true;
+        controls?: never;
+        tabIndex?: never;
+        "aria-hidden"?: never;
+    }, "ref">) & React__default.RefAttributes<HTMLVideoElement>>;
+};
+
 interface NavGroupItem {
     label: string;
     href: string;
@@ -579,7 +1001,7 @@ interface NavGroupProps {
     headingLevel?: NavGroupHeadingLevel;
     className?: string;
 }
-declare const NavGroup: ({ title, items, activeHref, headingLevel, className }: NavGroupProps) => React.JSX.Element;
+declare const NavGroup: ({ title, items, activeHref, headingLevel, className }: NavGroupProps) => React__default.JSX.Element;
 
 interface NavItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     children: ReactNode;
@@ -587,7 +1009,7 @@ interface NavItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     icon?: ReactNode;
     active?: boolean;
 }
-declare const NavItem: ({ children, icon, className, href, active, ...props }: NavItemProps) => React.JSX.Element;
+declare const NavItem: ({ children, icon, className, href, active, ...props }: NavItemProps) => React__default.JSX.Element;
 
 interface NumberFieldProps extends Omit<ComponentProps<"input">, "value" | "defaultValue" | "onChange" | "min" | "max" | "step" | "type" | "size" | "ref"> {
     value?: number | null;
@@ -614,7 +1036,30 @@ interface NumberFieldProps extends Omit<ComponentProps<"input">, "value" | "defa
  * A number typed or stepped. Base UI owns parsing, stepping, clamping, spinbutton semantics and
  * locale formatting; the ref points at the input, and the hidden form input is `inputRef`.
  */
-declare const NumberField: React.ForwardRefExoticComponent<NumberFieldProps & React.RefAttributes<HTMLInputElement>>;
+declare const NumberField: React__default.ForwardRefExoticComponent<NumberFieldProps & React__default.RefAttributes<HTMLInputElement>>;
+
+interface PaginationProps extends Omit<ComponentPropsWithoutRef<"nav">, "children" | "defaultValue" | "onChange"> {
+    /** Total number of pages. `0` is a valid pagination with nothing to navigate to. */
+    count: number;
+    /** The current page, 1-based. Supplying it makes the pagination controlled. */
+    value?: number;
+    /** The page an uncontrolled pagination starts on. */
+    defaultValue?: number;
+    /** Reports the page an ordinary activation asked for. */
+    onValueChange?: (page: number) => void;
+    /** Pages kept on each side of the current one, capped at 5 to keep rendering bounded. */
+    siblingCount?: number;
+    disabled?: boolean;
+    /** Renders every available page as a real anchor to the href this returns. */
+    getPageHref?: (page: number) => string;
+    /** The accessible name of a page control. Defaults to `Page {page}`. */
+    getPageLabel?: (page: number) => string;
+    /** Defaults to `Previous page`. */
+    previousLabel?: string;
+    /** Defaults to `Next page`. */
+    nextLabel?: string;
+}
+declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
 
 interface PopoverProps {
     children: ReactNode;
@@ -655,12 +1100,12 @@ interface PopoverContentProps {
  * capabilities this package supports, not the primitive's complete prop set. Composing a Base
  * primitive is how this component is built; it is not what it promises.
  */
-type PopoverComponent = ((props: PopoverProps) => React.JSX.Element) & {
+type PopoverComponent = ((props: PopoverProps) => React__default.JSX.Element) & {
     Trigger: typeof PopoverTrigger;
     Content: typeof PopoverContent;
 };
-declare const PopoverTrigger: ({ ...props }: PopoverTriggerProps) => React.JSX.Element;
-declare const PopoverContent: ({ children, className, side, align, sideOffset, alignOffset, }: PopoverContentProps) => React.JSX.Element;
+declare const PopoverTrigger: ({ ...props }: PopoverTriggerProps) => React__default.JSX.Element;
+declare const PopoverContent: ({ children, className, side, align, sideOffset, alignOffset, }: PopoverContentProps) => React__default.JSX.Element;
 declare const Popover: PopoverComponent;
 
 interface ProgressProps extends Omit<ComponentProps<"div">, "children">, Pick<Progress$1.Root.Props, "min" | "max" | "format" | "locale" | "getAriaValueText"> {
@@ -686,7 +1131,7 @@ interface ProgressProps extends Omit<ComponentProps<"div">, "children">, Pick<Pr
  * percentage and the accessible text; Sherick UI owns the recessed groove, the accent fill and the
  * sweep an unknown extent reports itself with.
  */
-declare const Progress: React.ForwardRefExoticComponent<Omit<ProgressProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Progress: React__default.ForwardRefExoticComponent<Omit<ProgressProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
 interface RadioGroupOption {
     value: string;
@@ -715,7 +1160,7 @@ interface RadioGroupProps extends Omit<ComponentProps<"div">, "onChange" | "defa
  * One choice out of a list. Base UI owns the value, the roving tab index, the arrow keys,
  * the name and the form participation; Sherick UI owns the labelled column and the rows.
  */
-declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroup: React__default.ForwardRefExoticComponent<Omit<RadioGroupProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
 interface SearchProps extends InputHTMLAttributes<HTMLInputElement> {
     onSearch: (value: string) => void;
@@ -726,7 +1171,7 @@ interface SearchProps extends InputHTMLAttributes<HTMLInputElement> {
     debounceMs?: number;
     inputClassName?: string;
 }
-declare const Search: React.ForwardRefExoticComponent<SearchProps & React.RefAttributes<HTMLInputElement>>;
+declare const Search: React__default.ForwardRefExoticComponent<SearchProps & React__default.RefAttributes<HTMLInputElement>>;
 
 interface SegmentedControlOption {
     value: string;
@@ -764,10 +1209,10 @@ interface SegmentedControlProps extends Omit<ComponentProps<"div">, "onChange" |
  * It names itself the way a tab list does — through `aria-label` / `aria-labelledby` — because it
  * is one control holding one value rather than a group of labelled controls.
  */
-declare const SegmentedControl: React.ForwardRefExoticComponent<Omit<SegmentedControlProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SegmentedControl: React__default.ForwardRefExoticComponent<Omit<SegmentedControlProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
 type SkeletonProps = HTMLAttributes<HTMLDivElement>;
-declare const Skeleton: ({ className, "aria-hidden": ariaHidden, ...props }: SkeletonProps) => React.JSX.Element;
+declare const Skeleton: ({ className, "aria-hidden": ariaHidden, ...props }: SkeletonProps) => React__default.JSX.Element;
 
 interface SliderProps extends Omit<ComponentProps<"div">, "defaultValue" | "onChange" | "children"> {
     value?: number;
@@ -797,7 +1242,7 @@ interface SliderProps extends Omit<ComponentProps<"div">, "defaultValue" | "onCh
 /**
  * A single handle on a groove. The ref points at the handle, which is the part a user grabs.
  */
-declare const Slider: React.ForwardRefExoticComponent<Omit<SliderProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Slider: React__default.ForwardRefExoticComponent<Omit<SliderProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
 declare const spinnerVariants: (props?: ({
     show?: boolean | null | undefined;
@@ -807,9 +1252,34 @@ declare const loaderVariants: (props?: ({
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface SpinnerProps extends VariantProps<typeof spinnerVariants>, VariantProps<typeof loaderVariants> {
     className?: string;
-    children?: React.ReactNode;
+    children?: React__default.ReactNode;
 }
-declare function Spinner({ size, show, children, className }: SpinnerProps): React.JSX.Element;
+declare function Spinner({ size, show, children, className }: SpinnerProps): React__default.JSX.Element;
+
+interface StepperItem {
+    value: string;
+    label: ReactNode;
+    description?: ReactNode;
+    complete?: boolean;
+    disabled?: boolean;
+}
+interface StepperProps extends Omit<ComponentProps<"nav">, "children" | "defaultValue" | "onChange"> {
+    items: StepperItem[];
+    /**
+     * The step the workflow has reached. Deliberately controlled, and deliberately nullable: the
+     * consumer owns the workflow, and `null` is a workflow that has not started, not its first step.
+     */
+    value: string | null;
+    /**
+     * Reports the step a native button activated. Its presence is what makes the list interactive:
+     * without it the steps are informative text, and no focusable fake controls are rendered.
+     */
+    onValueChange?: (value: string) => void;
+    /** Horizontal when the container has room; otherwise the same sequence stacks vertically. */
+    orientation?: "horizontal" | "vertical";
+    disabled?: boolean;
+}
+declare const Stepper: React__default.ForwardRefExoticComponent<Omit<StepperProps, "ref"> & React__default.RefAttributes<HTMLElement>>;
 
 interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value"> {
     checked?: boolean;
@@ -823,7 +1293,7 @@ interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "val
     required?: boolean;
     inputRef?: Ref<HTMLInputElement>;
 }
-declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Switch: React__default.ForwardRefExoticComponent<SwitchProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 type TabsChangeDetails = Parameters<NonNullable<Tabs$1.Root.Props["onValueChange"]>>[1];
 interface Tab {
@@ -842,7 +1312,7 @@ interface TabsProps {
     onValueChange?: (tabId: string, eventDetails: TabsChangeDetails) => void;
     ariaLabel?: string;
 }
-declare const Tabs: ({ tabs, variant, className, value, defaultValue, onValueChange, ariaLabel, }: TabsProps) => React.JSX.Element | null;
+declare const Tabs: ({ tabs, variant, className, value, defaultValue, onValueChange, ariaLabel, }: TabsProps) => React__default.JSX.Element | null;
 
 interface ToggleGroupProps extends Omit<ToggleGroup$1.Props<string>, "className" | "render"> {
     /** Styles the group's own track. The segments style themselves. */
@@ -861,7 +1331,7 @@ interface ToggleGroupItemProps extends Omit<Toggle.Props<string>, "value" | "chi
  * One option in a `ToggleGroup`. Segments are equal objects in one groove: unselected they show
  * the track through, and the selected one takes the selected tone and rises out of it.
  */
-declare const ToggleGroupItem: React.ForwardRefExoticComponent<Omit<ToggleGroupItemProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToggleGroupItem: React__default.ForwardRefExoticComponent<Omit<ToggleGroupItemProps, "ref"> & React__default.RefAttributes<HTMLButtonElement>>;
 type ToggleGroupComponent = ForwardRefExoticComponent<ToggleGroupProps & RefAttributes<HTMLDivElement>> & {
     Item: typeof ToggleGroupItem;
 };
@@ -880,7 +1350,7 @@ interface TableProps {
     rows: ReactNode[][];
     className?: string;
 }
-declare const Table: ({ headers, rows, className, }: TableProps) => React.JSX.Element;
+declare const Table: ({ headers, rows, className, }: TableProps) => React__default.JSX.Element;
 
 interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     label?: ReactNode;
@@ -891,7 +1361,7 @@ interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     /** Base's value-change callback, event details included. */
     onValueChange?: ComponentProps<typeof Field$1.Control>["onValueChange"];
 }
-declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
 
 interface TooltipProps {
     children: ReactElement;
@@ -899,7 +1369,71 @@ interface TooltipProps {
     className?: string;
     position?: "top" | "right" | "bottom" | "left";
 }
-declare const Tooltip: ({ children, content, className, position }: TooltipProps) => React.JSX.Element;
+declare const Tooltip: ({ children, content, className, position }: TooltipProps) => React__default.JSX.Element;
+
+/**
+ * The finite static tree a `TreeView` presents.
+ *
+ * A node is data, never markup: the tree renders the roles, the nesting and the indentation
+ * itself, so every node in it is reachable the same way whether it is a leaf or a branch.
+ * `value` identifies a node throughout the tree and is unique; `label` is what the node is
+ * called — its accessible name and what a typeahead search matches.
+ */
+interface TreeViewItem {
+    value: string;
+    label: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+    children?: TreeViewItem[];
+}
+
+interface TreeViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> {
+    /** The nodes to present. Values are unique across the whole tree. */
+    items: TreeViewItem[];
+    /** The tree's own accessible name. */
+    label: string;
+    /** The selected node, when the application owns the selection. */
+    value?: string | null;
+    /** The node selected at first, for a tree that owns its own selection. */
+    defaultValue?: string | null;
+    /** The node the user just chose, or `null` — selection never follows focus. */
+    onValueChange?: (value: string | null) => void;
+    /** The expanded nodes, when the application owns the expansion. */
+    expandedValues?: string[];
+    /** The nodes expanded at first, for a tree that owns its own expansion. */
+    defaultExpandedValues?: string[];
+    /** The nodes that should be expanded next. A controlled tree may decline the request. */
+    onExpandedValuesChange?: (values: string[]) => void;
+    /** Whether the whole tree is unavailable. A disabled node is disabled on its own. */
+    disabled?: boolean;
+    /**
+     * Renders a node's own label content — the part of the row beside its icon. It is labelled
+     * content rather than a control: `label` stays the node's accessible name, and what the tree
+     * renders here is what a reader sees, not a second place to put an action.
+     */
+    renderItem?: (item: TreeViewItem) => ReactNode;
+}
+/**
+ * A tree of nodes the user browses, expands and chooses from.
+ *
+ * Base UI ships no tree primitive — its composite internals are not a supported interface — so
+ * this component owns the APG treeview mechanics itself rather than opening a second headless
+ * layer beside Base: one roving tab stop, a visible node order the keyboard walks, a branch-only
+ * `aria-expanded`, and a selection that is deliberately independent of focus.
+ *
+ * Three things follow from that ownership, and they are the parts the API is built around:
+ *
+ * * **Focus and selection are two facts.** Arrow keys move the keyboard and never choose; Enter
+ *   and Space choose and never move. A node a typeahead lands on is not selected by arriving.
+ * * **A disabled node is local.** It stays discoverable and focusable so it can be announced as
+ *   unavailable, its already-visible children are untouched, and it simply cannot be chosen or
+ *   opened. A disabled *tree* dims once, at the root.
+ * * **The tree repairs its own focus, and only its own.** If a node leaves the tree — removed by
+ *   the application, or hidden by a branch that collapsed — the keyboard moves to the nearest
+ *   ancestor still shown, but only when the tree already had it. Focus that is somewhere else on
+ *   the page is never taken.
+ */
+declare const TreeView: React__default.ForwardRefExoticComponent<TreeViewProps & React__default.RefAttributes<HTMLDivElement>>;
 
 /**
  * Where a viewport-owning surface is attached. `center` is a dialog: it has no edge, so it rises
@@ -951,7 +1485,7 @@ interface DrawerFooterProps {
     children: ReactNode;
     className?: string;
 }
-type DrawerComponent = ((props: DrawerProps) => React.JSX.Element) & {
+type DrawerComponent = ((props: DrawerProps) => React__default.JSX.Element) & {
     Trigger: typeof DrawerTrigger;
     Content: typeof DrawerContent;
     Header: typeof DrawerHeader;
@@ -959,7 +1493,7 @@ type DrawerComponent = ((props: DrawerProps) => React.JSX.Element) & {
     Footer: typeof DrawerFooter;
     Close: typeof DrawerClose;
 };
-declare const DrawerTrigger: ({ ...props }: DrawerTriggerProps) => React.JSX.Element;
+declare const DrawerTrigger: ({ ...props }: DrawerTriggerProps) => React__default.JSX.Element;
 /**
  * The sheet itself: the plane behind it, the viewport, the edge-attached surface, and the
  * dismissal control every sheet carries. Base UI — through the same dialog root a `Dialog` uses —
@@ -970,11 +1504,11 @@ declare const DrawerTrigger: ({ ...props }: DrawerTriggerProps) => React.JSX.Ele
  * traps focus, restores it, locks the page and dismisses exactly as a dialog does. Use a `Dialog`
  * when the surface has no edge.
  */
-declare const DrawerContent: ({ children, className }: DrawerContentProps) => React.JSX.Element;
-declare const DrawerHeader: ({ children, className }: DrawerHeaderProps) => React.JSX.Element;
-declare const DrawerDescription: ({ children, className }: DrawerDescriptionProps) => React.JSX.Element;
-declare const DrawerFooter: ({ children, className }: DrawerFooterProps) => React.JSX.Element;
-declare const DrawerClose: (props: ComponentProps<typeof Dialog$1.Close>) => React.JSX.Element;
+declare const DrawerContent: ({ children, className }: DrawerContentProps) => React__default.JSX.Element;
+declare const DrawerHeader: ({ children, className }: DrawerHeaderProps) => React__default.JSX.Element;
+declare const DrawerDescription: ({ children, className }: DrawerDescriptionProps) => React__default.JSX.Element;
+declare const DrawerFooter: ({ children, className }: DrawerFooterProps) => React__default.JSX.Element;
+declare const DrawerClose: (props: ComponentProps<typeof Dialog$1.Close>) => React__default.JSX.Element;
 /**
  * A surface attached to one edge of the viewport: a bottom sheet, a side panel, a top drawer. It
  * is a `Dialog` with an edge rather than a second kind of modal — the same root, the same scrim,
@@ -1079,14 +1613,14 @@ interface ToastViewportProps {
  * region and its priority, swipe dismissal and the stack's own state; Sherick UI owns the surface
  * and how the stack moves.
  */
-declare const ToastProvider: ({ children, manager, ...props }: ToastProviderProps) => React.JSX.Element;
+declare const ToastProvider: ({ children, manager, ...props }: ToastProviderProps) => React__default.JSX.Element;
 /**
  * The stack, and the only place a toast is rendered. Put one inside `ToastProvider` at the root of
  * the application: `useToast().add(...)` raises a toast, and this renders every toast the manager
  * is holding. Base provides F6 entry and focus restoration; the live region remains available
  * while a modal is open. Keep the keyboard shortcut discoverable without reimplementing it.
  */
-declare const ToastViewport: ({ position, className }: ToastViewportProps) => React.JSX.Element;
+declare const ToastViewport: ({ position, className }: ToastViewportProps) => React__default.JSX.Element;
 /**
  * Raises, updates and closes toasts from inside the React tree. The handle is stable for as long as
  * the provider is, so it can be listed as a dependency without churning an effect.
@@ -1105,7 +1639,7 @@ interface DirectionProviderProps {
     children: ReactNode;
 }
 /** Declares writing direction to the interaction and positioning primitives, including portals. */
-declare const DirectionProvider: ({ direction, children }: DirectionProviderProps) => React.JSX.Element;
+declare const DirectionProvider: ({ direction, children }: DirectionProviderProps) => React__default.JSX.Element;
 
-export { Accordion, Alert, AlertDialog, Avatar, Badge, Button, Card, Checkbox, Chip, ChipGroup, Collapsible, Combobox, Dialog, DirectionProvider, Divider, Drawer, Field, IconButton, Input, Menu, NavGroup, NavItem, NumberField, Popover, Progress, RadioGroup, Search, SegmentedControl, Select, Skeleton, Slider, Spinner, Switch, Table, Tabs, Textarea, ToastProvider, ToastViewport, ToggleGroup, Tooltip, createToastManager, useToast };
-export type { AccordionHeadingLevel, AccordionItemProps, AccordionPanelProps, AccordionProps, AccordionTriggerProps, AlertDialogProps, AlertProps, AvatarProps, BadgeProps, ButtonAppearance, ButtonProps, ButtonSize, CardProps, CheckboxProps, ChipGroupProps, ChipProps, CollapsiblePanelProps, CollapsibleProps, CollapsibleTriggerProps, ComboboxOption, ComboboxProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogProps, DirectionProviderProps, DividerProps, DividerWeight, DrawerContentProps, DrawerDescriptionProps, DrawerFooterProps, DrawerHeaderProps, DrawerProps, DrawerSide, DrawerTriggerProps, FieldProps, IconButtonAppearance, IconButtonProps, InputProps, MenuContentProps, MenuItemProps, MenuProps, MenuSeparatorProps, MenuTriggerProps, NavGroupHeadingLevel, NavGroupItem, NavGroupProps, NavItemProps, NumberFieldProps, OverlayAlign, OverlaySide, PopoverContentProps, PopoverProps, PopoverTriggerProps, ProgressProps, RadioGroupOption, RadioGroupProps, SearchProps, SegmentedControlOption, SegmentedControlProps, SelectOption, SelectProps, SkeletonProps, SliderProps, SpinnerProps, SwitchProps, Tab, TableProps, TabsProps, TextareaProps, ToastActionOptions, ToastManager, ToastOptions, ToastPosition, ToastPromiseOptions, ToastProviderProps, ToastType, ToastUpdateOptions, ToastViewportProps, ToggleGroupItemProps, ToggleGroupProps, TooltipProps, Variant };
+export { Accordion, Alert, AlertDialog, Avatar, Badge, Breadcrumb, Button, Calendar, Card, Checkbox, Chip, ChipGroup, Collapsible, Combobox, Command, CommandPalette, DatePicker, DateRangePicker, Dialog, DirectionProvider, Divider, Drawer, Field, FileUpload, IconButton, Input, Media, Menu, NavGroup, NavItem, NumberField, Pagination, Popover, Progress, RadioGroup, Search, SegmentedControl, Select, Skeleton, Slider, Spinner, Stepper, Switch, Table, Tabs, Textarea, ToastProvider, ToastViewport, ToggleGroup, Tooltip, TreeView, createToastManager, useToast };
+export type { AccordionHeadingLevel, AccordionItemProps, AccordionPanelProps, AccordionProps, AccordionTriggerProps, AlertDialogProps, AlertProps, AvatarProps, BadgeProps, BreadcrumbItem, BreadcrumbProps, ButtonAppearance, ButtonProps, ButtonSize, CalendarDate, CalendarLabels, CalendarProps, CardProps, CheckboxProps, ChipGroupProps, ChipProps, CollapsiblePanelProps, CollapsibleProps, CollapsibleTriggerProps, ComboboxOption, ComboboxProps, CommandItem, CommandPaletteProps, CommandProps, DatePickerProps, DateRange, DateRangePickerProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogProps, DirectionProviderProps, DividerProps, DividerWeight, DrawerContentProps, DrawerDescriptionProps, DrawerFooterProps, DrawerHeaderProps, DrawerProps, DrawerSide, DrawerTriggerProps, FieldProps, FileRejection, FileUploadProps, IconButtonAppearance, IconButtonProps, InputProps, MediaImageProps, MediaVideoProps, MenuContentProps, MenuItemProps, MenuProps, MenuSeparatorProps, MenuTriggerProps, NavGroupHeadingLevel, NavGroupItem, NavGroupProps, NavItemProps, NumberFieldProps, OverlayAlign, OverlaySide, PaginationProps, PopoverContentProps, PopoverProps, PopoverTriggerProps, ProgressProps, RadioGroupOption, RadioGroupProps, SearchProps, SegmentedControlOption, SegmentedControlProps, SelectOption, SelectProps, SkeletonProps, SliderProps, SpinnerProps, StepperItem, StepperProps, SwitchProps, Tab, TableProps, TabsProps, TextareaProps, ToastActionOptions, ToastManager, ToastOptions, ToastPosition, ToastPromiseOptions, ToastProviderProps, ToastType, ToastUpdateOptions, ToastViewportProps, ToggleGroupItemProps, ToggleGroupProps, TooltipProps, TreeViewItem, TreeViewProps, Variant };