sherick-ui 2.8.0 → 2.10.1

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import { Accordion as Accordion$1 } from '@base-ui/react/accordion';
 import * as React from 'react';
-import React__default, { ReactNode, ButtonHTMLAttributes, ImgHTMLAttributes, HTMLAttributes, ComponentPropsWithoutRef, AnchorHTMLAttributes, ComponentProps, Ref, ClipboardEvent, ReactElement, InputHTMLAttributes, ForwardRefExoticComponent, RefAttributes, MouseEventHandler, ComponentPropsWithRef, TextareaHTMLAttributes } from 'react';
+import React__default, { ReactNode, ComponentPropsWithoutRef, ElementType, ButtonHTMLAttributes, ReactElement, ForwardRefExoticComponent, RefAttributes, HTMLAttributes, AnchorHTMLAttributes, ComponentProps, Ref, ClipboardEvent, InputHTMLAttributes, MouseEventHandler, ComponentPropsWithRef, Key, 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';
@@ -8,13 +8,14 @@ import { CheckboxGroup as CheckboxGroup$1 } from '@base-ui/react/checkbox-group'
 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 { Field as Field$1 } from '@base-ui/react/field';
 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 { Form as Form$1 } from '@base-ui/react/form';
 import { Input as Input$1 } from '@base-ui/react/input';
+import * as _base_ui_react from '@base-ui/react';
 import { Menu as Menu$1 } from '@base-ui/react/menu';
 import { NumberField as NumberField$1 } from '@base-ui/react/number-field';
 import { Progress as Progress$1 } from '@base-ui/react/progress';
@@ -132,6 +133,20 @@ type Variant = "primary" | "secondary" | "danger" | "warning" | "success";
  */
 type OverlaySide = "top" | "bottom" | "left" | "right" | "inline-start" | "inline-end";
 type OverlayAlign = "start" | "center" | "end";
+/**
+ * The props a primitive hands to the element it renders in its place (Base's `render`): the
+ * button's own attributes, and the event and state wiring Base adds to them. The ref is passed
+ * separately, so a trigger that forwards one takes it beside these props rather than inside them.
+ *
+ * The triggers of Menu, Popover, Drawer, Dialog and AlertDialog take this shape, so a trigger
+ * built on any of them accepts the same element.
+ */
+type TriggerProps = ComponentPropsWithoutRef<"button">;
+/**
+ * The props of the element a part renders, without its ref. A part that forwards a ref takes
+ * the ref beside these props; `T` is the element the part is written as.
+ */
+type PartProps<T extends ElementType> = ComponentPropsWithoutRef<T>;
 
 type ButtonAppearance = "filled" | "tonal" | "text";
 type ButtonSize = "sm" | "md" | "lg";
@@ -142,17 +157,38 @@ interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     size?: ButtonSize;
     icon?: ReactNode;
     loading?: boolean;
+    /**
+     * The element the button renders as, such as a router link. The button's classes and its own props
+     * are merged onto it, so the link looks and presses like a button and keeps its own navigation.
+     */
+    render?: ReactElement;
 }
 declare const Button: React__default.ForwardRefExoticComponent<ButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
 
-interface AlertProps {
+/** How an alert is announced to assistive technology. `none` leaves it silent. */
+type AlertAnnounce = "none" | "status" | "alert";
+interface AlertProps extends Omit<ComponentPropsWithoutRef<"div">, "role"> {
     children: ReactNode;
     variant?: Variant;
-    className?: string;
+    /** Whether the alert has a dismiss control. */
     closeable?: boolean;
+    /** The dismiss control's accessible name. Override it when the surface's language is not the default. */
+    dismissLabel?: string;
+    /**
+     * How the alert is announced. `alert` interrupts the reader, `status` is read politely, and `none`
+     * adds no live role. Danger and warning default to `alert`, and every other variant to `status`.
+     */
+    announce?: AlertAnnounce;
+    /** Whether the alert is shown, when the application owns that state. */
+    open?: boolean;
+    /** Whether the alert starts shown, for one that owns its own dismissal. */
+    defaultOpen?: boolean;
+    /** Reports `false` when the alert is dismissed, for a controlled alert or to observe an uncontrolled one. */
+    onOpenChange?: (open: boolean) => void;
+    /** Fires when the alert is dismissed, before its open state changes. */
     onDismiss?: () => void;
 }
-declare const Alert: ({ children, variant, className, closeable, onDismiss, }: AlertProps) => React__default.JSX.Element | null;
+declare const Alert: React__default.ForwardRefExoticComponent<AlertProps & React__default.RefAttributes<HTMLDivElement>>;
 
 interface AlertDialogProps {
     /** The question the dialog asks. Base makes it the surface's accessible name. */
@@ -179,7 +215,18 @@ interface AlertDialogProps {
     defaultOpen?: boolean;
     /** Base's own open-change callback, event details included. */
     onOpenChange?: AlertDialog$1.Root.Props["onOpenChange"];
+    /** The `AlertDialog.Trigger` that opens the dialog. It renders in the page, beside the trigger's own control. */
+    children?: ReactNode;
 }
+/** The control that opens an alert dialog. Base's trigger closes it again through the same root. */
+type AlertDialogTriggerProps = TriggerProps & {
+    /** The element the trigger's own props are handed to — usually a Sherick `Button`. */
+    render?: ReactElement;
+};
+declare const AlertDialogTrigger: ({ render, ...props }: AlertDialogTriggerProps) => React__default.JSX.Element;
+type AlertDialogComponent = ForwardRefExoticComponent<AlertDialogProps & RefAttributes<HTMLDivElement>> & {
+    Trigger: typeof AlertDialogTrigger;
+};
 /**
  * A dialog that asks one question and requires one answer. Its interaction contract differs from
  * `Dialog`: it is always modal, an outside press never dismisses it, and Base's default focus
@@ -187,27 +234,37 @@ 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__default.ForwardRefExoticComponent<AlertDialogProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const AlertDialog: AlertDialogComponent;
 
-interface AvatarProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "src" | "alt" | "width" | "height"> {
+interface AvatarProps extends Omit<ComponentPropsWithoutRef<"span">, "children"> {
     src: string;
     alt: string;
     size?: "sm" | "md" | "lg";
     shape?: "circle" | "rounded";
+    /**
+     * What stands in for the picture while it loads and after it fails. Defaults to the initials of `alt`,
+     * so an avatar with no picture still says who it is.
+     */
+    fallback?: ReactNode;
 }
-declare const Avatar: ({ src, alt, size, shape: shapeRole, className, ...props }: AvatarProps) => React__default.JSX.Element;
+declare const Avatar: React__default.ForwardRefExoticComponent<AvatarProps & React__default.RefAttributes<HTMLSpanElement>>;
 
 interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
     children: ReactNode;
     variant?: Variant;
     icon?: ReactNode;
 }
-declare const Badge: ({ children, variant, icon, className, ...props }: BadgeProps) => React__default.JSX.Element;
+declare const Badge: React__default.ForwardRefExoticComponent<BadgeProps & React__default.RefAttributes<HTMLSpanElement>>;
 
 interface BreadcrumbItem {
     label: ReactNode;
     href?: string;
 }
+/** The English copy a trail names itself with. */
+interface BreadcrumbLabels {
+    /** The trail's accessible name. */
+    navigation: string;
+}
 interface BreadcrumbProps extends Omit<ComponentPropsWithoutRef<"nav">, "children"> {
     items: BreadcrumbItem[];
     /**
@@ -216,6 +273,8 @@ interface BreadcrumbProps extends Omit<ComponentPropsWithoutRef<"nav">, "childre
      * spreads them onto its element.
      */
     renderLink?: (item: BreadcrumbItem, props: AnchorHTMLAttributes<HTMLAnchorElement>) => ReactNode;
+    /** The English copy the trail names itself with. `aria-label` takes precedence over it. */
+    labels?: Partial<BreadcrumbLabels>;
 }
 declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
 
@@ -262,7 +321,10 @@ interface CalendarBaseProps extends Omit<ComponentProps<"div">, "children" | "va
     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. */
+    /**
+     * The civil day this application calls today. Left unset, it is the viewer's own local day, refreshed at
+     * local midnight; an application whose day is elsewhere passes its own.
+     */
     today?: CalendarDate;
     labels?: Partial<CalendarLabels>;
 }
@@ -304,7 +366,17 @@ interface CardProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
     variant?: Variant;
 }
-declare const Card: ({ children, variant, className, ...props }: CardProps) => React__default.JSX.Element;
+interface CardTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+    children: ReactNode;
+    /** The heading level is the host document's business, so it is a prop rather than a fixed level. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+}
+type CardDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+type CardComponent = ForwardRefExoticComponent<CardProps & RefAttributes<HTMLDivElement>> & {
+    Title: ForwardRefExoticComponent<CardTitleProps & RefAttributes<HTMLHeadingElement>>;
+    Description: ForwardRefExoticComponent<CardDescriptionProps & RefAttributes<HTMLParagraphElement>>;
+};
+declare const Card: CardComponent;
 
 interface CheckboxProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "type"> {
     checked?: boolean;
@@ -383,19 +455,11 @@ interface ChipAnatomy {
     className?: string;
 }
 /**
- * A chip is one of two things, and never both.
- *
- * * A **toggle chip** holds a selection. Supplying any of `checked`, `defaultChecked`,
- *   `onCheckedChange` or `value` makes it a toggle button, and it takes the props of one; inside a
- *   `ChipGroup` the group owns the value, exactly as it does for any grouped control.
- * * A **tag** holds no selection and may be dismissed. `onRemove` renders the dismiss control, and
- *   the tag takes the props of the passive element it is.
- *
- * The two cannot be combined: a control that both holds a value and deletes itself is one target
- * with two meanings, and a toggle is a `<button>` while a tag is a `<span>` containing its dismiss
- * control — a button cannot legally nest inside a button.
+ * A toggle chip holds a selection. Supplying any of `checked`, `defaultChecked`, `onCheckedChange` or
+ * `value` makes it a toggle button, and it takes the props of one; inside a `ChipGroup` the group owns
+ * the value, exactly as it does for any grouped control.
  */
-type ChipProps = (ChipAnatomy & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "type"> & {
+type ChipToggleProps = ChipAnatomy & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "type"> & {
     /** The controlled counterpart of `defaultChecked`. */
     checked?: boolean;
     defaultChecked?: boolean;
@@ -406,12 +470,18 @@ type ChipProps = (ChipAnatomy & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "v
     /** A toggle is a button; it carries no dismiss control. Give the row a `ChipGroup`. */
     onRemove?: never;
     removeLabel?: never;
-}) | (ChipAnatomy & HTMLAttributes<HTMLSpanElement> & {
+};
+/**
+ * A tag holds no selection and may be dismissed. It is a span, so it has no button role; its only
+ * control is the dismiss, which is what `onRemove` renders. A tag is `Chip.Tag`, or a `Chip` with
+ * `onRemove` and no value.
+ */
+type ChipTagProps = ChipAnatomy & HTMLAttributes<HTMLSpanElement> & {
     /** Renders a dismiss control. */
     onRemove?: () => void;
     /**
-     * The dismiss control's accessible name. Defaults to `Remove <text>` when the chip's
-     * children are a string, and to `Remove` otherwise.
+     * The dismiss control's accessible name. Defaults to `Remove <text>` when the chip's children are a
+     * string, and to `Remove` otherwise.
      */
     removeLabel?: string;
     /** A tag holds nothing to select. */
@@ -420,17 +490,30 @@ type ChipProps = (ChipAnatomy & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "v
     onCheckedChange?: never;
     value?: never;
     disabled?: never;
-});
+};
 /**
- * A compact control-sized object: a toggle button that holds a selection, or a tag that carries its
- * tone in its fill and can be dismissed.
- *
- * A toggle is raised and tactile because it is manipulated. A tag is flat because it is only read,
- * and it is passive in the markup as well: nothing about its own box is interactive, its copy keeps
- * 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.
+ * A chip is one of two things, and never both. A toggle is a `<button>`, and a tag is a `<span>`
+ * containing its dismiss control: a button cannot legally nest inside a button, and a control that both
+ * holds a value and deletes itself is one target with two meanings.
  */
-declare const Chip: React__default.ForwardRefExoticComponent<ChipProps & React__default.RefAttributes<HTMLElement>>;
+type ChipProps = ChipToggleProps | ChipTagProps;
+declare const Chip: React__default.ForwardRefExoticComponent<ChipProps & React__default.RefAttributes<HTMLElement>> & {
+    Tag: React__default.ForwardRefExoticComponent<ChipAnatomy & React__default.HTMLAttributes<HTMLSpanElement> & {
+        /** Renders a dismiss control. */
+        onRemove?: () => void;
+        /**
+         * The dismiss control's accessible name. Defaults to `Remove <text>` when the chip's children are a
+         * string, and to `Remove` otherwise.
+         */
+        removeLabel?: string;
+        /** A tag holds nothing to select. */
+        checked?: never;
+        defaultChecked?: never;
+        onCheckedChange?: never;
+        value?: never;
+        disabled?: never;
+    } & React__default.RefAttributes<HTMLElement>>;
+};
 
 interface ChipGroupProps extends Omit<ToggleGroup$1.Props<string>, "multiple" | "className" | "render"> {
     children: ReactNode;
@@ -459,6 +542,46 @@ interface OptionGroup<Option> {
     options: Option[];
 }
 
+/** The density a field takes: `sm` for a dense row, `md` the default and `lg` a prominent field. */
+type FieldSize = "sm" | "md" | "lg";
+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. */
+    label?: ReactNode;
+    /** Supporting copy beneath the control. In a horizontal field it sits beneath the label. */
+    description?: ReactNode;
+    /**
+     * The message shown while the field is invalid. Its presence is what makes the field invalid,
+     * so an error can never be rendered without the state that explains it. Omit it and Base UI's
+     * own validation message is shown instead.
+     */
+    error?: ReactNode;
+    /**
+     * Renders the required mark beside the label. This is presentational only: the requirement
+     * itself can only be declared by the control, so pass `required` to the control as well —
+     * every example, fixture and test in this repository does.
+     */
+    required?: boolean;
+    /**
+     * `vertical` stacks the label, the control, the description and the error in one column. `horizontal`
+     * is a setting row: the label and its description sit at the start and the control at the end.
+     */
+    orientation?: "vertical" | "horizontal";
+    /** Styles the field's own column. The control inside styles itself. */
+    className?: string;
+    /**
+     * A Base-backed control that is one control: `Checkbox`, `Switch`, `Slider`, `NumberField`, `Select`
+     * or `Combobox`. A group of controls names itself — `RadioGroup` carries its own label — because
+     * the field's label belongs to the single control it validates.
+     */
+    children: ReactNode;
+}
+/**
+ * Labels and validates one form control. Base UI owns the generated IDs and the
+ * `aria-describedby` / `aria-invalid` wiring; this component owns only the order and the
+ * typography of label, control, description and error.
+ */
+declare const Field: React__default.ForwardRefExoticComponent<FieldProps & React__default.RefAttributes<HTMLDivElement>>;
+
 interface ComboboxOption {
     label: string;
     value: string;
@@ -466,6 +589,19 @@ interface ComboboxOption {
 }
 /** Options filed under one heading, such as channels under their category. */
 type ComboboxOptionGroup = OptionGroup<ComboboxOption>;
+/** The copy of the control's own parts. Each default is the text the control has always shown. */
+interface ComboboxLabels {
+    /** The accessible name of one chip's dismiss control. */
+    removeChip: (label: string) => string;
+    /** The clear control of a multiple combobox. */
+    clearAll: string;
+    /** The clear control of a single combobox. */
+    clearSelection: string;
+    /** The trigger that opens the list. */
+    showOptions: string;
+    /** Shown in the list when the query matches nothing. `emptyMessage` replaces it. */
+    noResults: string;
+}
 type ComboboxRootProps = Combobox$1.Root.Props<ComboboxOption>;
 type ComboboxChangeDetails = Parameters<NonNullable<ComboboxRootProps["onValueChange"]>>[1];
 /**
@@ -485,8 +621,16 @@ interface ComboboxCommonProps {
     placeholder?: string;
     /** Shown in place of the list when the query matches no option. */
     emptyMessage?: ReactNode;
+    /** Waiting for its options: a spinner takes the chevron's place and the trigger reports itself busy. */
+    loading?: boolean;
+    /** The field's density: `sm` for a dense filter row, `md` (the default) or `lg`. */
+    size?: FieldSize;
+    /** The copy of the control's own parts, for a locale or a product's wording. */
+    labels?: Partial<ComboboxLabels>;
     /** Styles the control's own box. The popup and its rows style themselves. */
     className?: string;
+    /** Styles the list's own sheet. The rows style themselves. */
+    popupClassName?: string;
     /** Custom matching, when the default label search is not what the list needs. */
     filter?: ((option: ComboboxOption, query: string) => boolean) | null;
     open?: boolean;
@@ -558,6 +702,15 @@ type ComboboxProps = ComboboxSingleProps | ComboboxMultipleProps;
  */
 declare const Combobox: React__default.ForwardRefExoticComponent<ComboboxProps & React__default.RefAttributes<HTMLInputElement>>;
 
+/** The English copy a command list names itself and its parts with. */
+interface CommandLabels {
+    /** The search field's accessible name, when the caller does not give one. */
+    search: string;
+    /** The search field's placeholder. */
+    placeholder: string;
+    /** Shown in place of the list when the query matches no command. */
+    empty: string;
+}
 interface CommandItem {
     /** The action's own identity. Values are unique across the list. */
     value: string;
@@ -587,9 +740,9 @@ 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.
+     * heading names the surface — so it is not rendered as visible copy. Defaults to "Search commands".
      */
-    label: string;
+    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
@@ -602,9 +755,12 @@ interface CommandProps {
     defaultValue?: string;
     /** Base's own query-change callback, event details included. */
     onValueChange?: (value: string, eventDetails: CommandQueryChangeDetails) => void;
+    /** The search field's placeholder. Defaults to the placeholder in `labels`. */
     placeholder?: string;
-    /** Shown in place of the list when the query matches no command. */
+    /** Shown in place of the list when the query matches no command. Defaults to the empty text in `labels`. */
     emptyMessage?: ReactNode;
+    /** The English copy the list names itself and its parts with. The props above take precedence over it. */
+    labels?: Partial<CommandLabels>;
     disabled?: boolean;
     /** A string comparison locale for the default matching. */
     locale?: string;
@@ -638,6 +794,23 @@ interface CommandProps {
  */
 declare const Command: React__default.ForwardRefExoticComponent<CommandProps & React__default.RefAttributes<HTMLInputElement>>;
 
+/**
+ * Where a viewport-owning surface is attached. `center` is a dialog: it has no edge, so it rises
+ * into the middle of the viewport and takes the modal presence. Every other value is a sheet
+ * attached to that edge of the viewport, and slides out of it.
+ */
+type DialogAttachment = "center" | "bottom" | "top" | "left" | "right";
+type DialogTriggerProps = TriggerProps & {
+    /** The element the trigger's own props are handed to — usually a Sherick `Button`. */
+    render?: ReactElement;
+};
+/**
+ * The control that opens a dialog-family surface. It renders in the page rather than in the portal,
+ * so the reader sees the control they pressed and the surface arrives from it. Base's trigger closes
+ * the surface through its own root, so no open state is needed beside it.
+ */
+declare const DialogTrigger: ({ render, ...props }: DialogTriggerProps) => React__default.JSX.Element;
+
 interface CommandPaletteProps extends Omit<CommandProps, "className" | "id"> {
     /** The surface's own heading. It names the dialog. */
     title: string;
@@ -646,15 +819,23 @@ interface CommandPaletteProps extends Omit<CommandProps, "className" | "id"> {
     /**
      * 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.
+     * It is a convenience over `CommandPalette.Trigger`, which does the same thing as a part.
      */
     trigger?: ReactElement;
+    /** `CommandPalette.Trigger` parts that open the palette. They render in the page, beside the trigger. */
+    children?: ReactNode;
     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 accessible name of the dismissal control. Defaults to "Close command palette". */
+    closeLabel?: string;
 }
+type CommandPaletteComponent = ForwardRefExoticComponent<CommandPaletteProps & RefAttributes<HTMLInputElement>> & {
+    Trigger: typeof DialogTrigger;
+};
 /**
  * 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
@@ -671,7 +852,7 @@ interface CommandPaletteProps extends Omit<CommandProps, "className" | "id"> {
  * 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>>;
+declare const CommandPalette: CommandPaletteComponent;
 
 interface DatePickerProps {
     /** The selected date, or `null` for no selection. Undefined makes the picker uncontrolled. */
@@ -680,7 +861,11 @@ interface DatePickerProps {
     /** 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;
+    label?: ReactNode;
+    /** Names the field when `label` is absent or is not text, since the popup and its control need words. */
+    "aria-label"?: string;
+    /** The field's density: `sm` for a dense filter row, `md` (the default) or `lg`. */
+    size?: FieldSize;
     description?: ReactNode;
     error?: ReactNode;
     required?: boolean;
@@ -858,13 +1043,13 @@ declare const edgeTone: {
  * column header — so a caller names the join it is drawing rather than picking an opacity.
  */
 type DividerWeight = keyof typeof edgeTone;
-interface DividerProps {
+interface DividerProps extends Omit<ComponentPropsWithoutRef<"div">, "className"> {
     className?: string;
     orientation?: "horizontal" | "vertical";
     /** The weight of the line. `rule` is the general section break. */
     weight?: DividerWeight;
 }
-declare const Divider: ({ className, orientation, weight }: DividerProps) => React__default.JSX.Element;
+declare const Divider: React__default.ForwardRefExoticComponent<DividerProps & React__default.RefAttributes<HTMLDivElement>>;
 
 interface SelectOption {
     label: string;
@@ -887,43 +1072,21 @@ interface SelectProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "val
     /** Base's value-change event details are passed through unchanged. */
     onValueChange?: (value: string | null, eventDetails: SelectChangeDetails) => void;
     placeholder?: string;
-    readOnly?: boolean;
-    required?: boolean;
-}
-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. */
-    label?: ReactNode;
-    /** Supporting copy beneath the control. */
-    description?: ReactNode;
-    /**
-     * The message shown while the field is invalid. Its presence is what makes the field invalid,
-     * so an error can never be rendered without the state that explains it. Omit it and Base UI's
-     * own validation message is shown instead.
-     */
-    error?: ReactNode;
     /**
-     * Renders the required mark beside the label. This is presentational only: the requirement
-     * itself can only be declared by the control, so pass `required` to the control as well —
-     * every example, fixture and test in this repository does.
+     * Shown in the list when there are no options. With no message either, the list does not open at all,
+     * so an empty select never shows an empty sheet.
      */
+    emptyMessage?: ReactNode;
+    /** Waiting for its options: a spinner takes the chevron's place and the trigger reports itself busy. */
+    loading?: boolean;
+    /** The field's density: `sm` for a dense filter row, `md` (the default) or `lg`. */
+    size?: FieldSize;
+    /** Styles the list's own sheet. The trigger is styled through `className`, and the rows style themselves. */
+    popupClassName?: string;
+    readOnly?: boolean;
     required?: boolean;
-    /** Styles the field's own column. The control inside styles itself. */
-    className?: string;
-    /**
-     * A Base-backed control that is one control: `Checkbox`, `Slider` or `NumberField`. A
-     * group of controls names itself — `RadioGroup` carries its own label — because the
-     * field's label belongs to the single control it validates.
-     */
-    children: ReactNode;
 }
-/**
- * Labels and validates one form control. Base UI owns the generated IDs and the
- * `aria-describedby` / `aria-invalid` wiring; this component owns only the order and the
- * typography of label, control, description and error.
- */
-declare const Field: React__default.ForwardRefExoticComponent<FieldProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const Select: React__default.ForwardRefExoticComponent<SelectProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 type RejectionCode = "type" | "size" | "count";
 /** One file a selection operation refused, with the reason it was refused. */
@@ -933,6 +1096,15 @@ interface FileRejection {
     message: string;
 }
 
+/** The copy of the selection's announcements. Each default is the text the field has always announced. */
+interface FileUploadLabels {
+    /** Announced when one file is removed. */
+    removedFile: (name: string) => string;
+    /** Announced when several files are removed. */
+    removedFiles: (count: number) => string;
+    /** Announced when files are added. */
+    addedFiles: (count: number) => string;
+}
 /**
  * A labelled field that selects files from the native picker or by dropping them on its zone.
  *
@@ -948,8 +1120,8 @@ interface FileRejection {
  * 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;
+    /** The field's label. It names the picker when it is text, and is absent when the zone speaks for itself. */
+    label?: ReactNode;
     /** Supporting copy beneath the field. */
     description?: ReactNode;
     /**
@@ -984,6 +1156,8 @@ interface FileUploadProps extends Omit<HTMLAttributes<HTMLDivElement>, "children
     removeLabel?: (file: File) => string;
     /** The accessible name of the control that empties the selection. */
     clearLabel?: string;
+    /** The copy of the selection's announcements, for a locale or a product's wording. */
+    labels?: Partial<FileUploadLabels>;
 }
 declare const FileUpload: React__default.ForwardRefExoticComponent<FileUploadProps & React__default.RefAttributes<HTMLInputElement>>;
 
@@ -1013,19 +1187,31 @@ interface FormProps extends Omit<ComponentProps<typeof Form$1>, "className" | "r
  */
 declare const Form: React__default.ForwardRefExoticComponent<FormProps & React__default.RefAttributes<HTMLFormElement>>;
 
-type IconButtonAppearance = "tonal" | "ghost" | "acrylic";
+type IconButtonAppearance = "tonal" | "filled" | "text" | "ghost" | "acrylic";
+type IconButtonSize = "target" | "compact";
 interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     variant?: Variant;
     appearance?: IconButtonAppearance;
+    size?: IconButtonSize;
     icon?: ReactNode;
     loading?: boolean;
+    /**
+     * The element the button renders as, such as a router link. The button's classes and its own props
+     * are merged onto it, so the link keeps the button's look and its own navigation.
+     */
+    render?: ReactElement;
 }
 declare const IconButton: React__default.ForwardRefExoticComponent<IconButtonProps & React__default.RefAttributes<HTMLButtonElement>>;
 
-interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "prefix"> {
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "prefix" | "size"> {
     label?: ReactNode;
     description?: ReactNode;
-    error?: boolean;
+    /**
+     * Marks the field invalid. A message is shown beneath it, so a `ReactNode` here is both the flag and
+     * its message. `true` marks the field without one, and `errorMessage` supplies the message.
+     */
+    error?: ReactNode;
+    /** The message for `error={true}`. A message passed as `error` takes its place. */
     errorMessage?: ReactNode;
     inputClassName?: string;
     /** Base's value-change callback, event details included. */
@@ -1037,26 +1223,29 @@ interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "prefix
     prefix?: ReactNode;
     /** Text or a mark at the end of the field, such as `tickets` or `.discord.gg`. Presentation only. */
     suffix?: ReactNode;
+    /**
+     * The field's density: `sm` for a dense filter row, `md` (the default) or `lg`. A number is the
+     * native `size` attribute of the input, as it always was.
+     */
+    size?: FieldSize | number;
 }
 declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;
 
-type DialogContentProps = HTMLAttributes<HTMLDivElement>;
-declare const DialogContent: ({ children, className, ...props }: DialogContentProps) => React__default.JSX.Element;
+/** The body's own `div`. It keeps the body meaning it has always had. */
+type DialogContentProps = PartProps<"div">;
+declare const DialogContent: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
+/** The supporting line's own `p`, as Base renders it. */
 type DialogDescriptionProps = ComponentPropsWithoutRef<typeof Dialog$1.Description>;
-declare const DialogDescription: ({ className, ...props }: DialogDescriptionProps) => React__default.JSX.Element;
+declare const DialogDescription: React__default.ForwardRefExoticComponent<Omit<Omit<_base_ui_react.AlertDialogDescriptionProps, "ref"> & React__default.RefAttributes<HTMLParagraphElement>, "ref"> & React__default.RefAttributes<HTMLParagraphElement>>;
 
-interface DialogFooterProps {
-    children: ReactNode;
-    className?: string;
-}
-declare const DialogFooter: ({ children, className }: DialogFooterProps) => React__default.JSX.Element;
+/** The footer's own `div`, which holds the dialog's actions. */
+type DialogFooterProps = PartProps<"div">;
+declare const DialogFooter: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
-interface DialogHeaderProps {
-    children: ReactNode;
-    className?: string;
-}
-declare const DialogHeader: ({ children, className }: DialogHeaderProps) => React__default.JSX.Element;
+/** The header's own `div`. Its children are the title: Base names the surface from them. */
+type DialogHeaderProps = PartProps<"div">;
+declare const DialogHeader: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
 interface DialogProps {
     children: ReactNode;
@@ -1065,12 +1254,22 @@ interface DialogProps {
     /** Base's open-change callback, event details included. */
     onOpenChange?: Dialog$1.Root.Props["onOpenChange"];
     className?: string;
+    /** The accessible name of the dismissal control. Defaults to "Close dialog". */
+    closeLabel?: string;
 }
+/**
+ * The close control of a dialog. It is Base's own close part, so whatever the caller renders closes
+ * the dialog through Base, with no open state of the caller's own.
+ */
+type DialogCloseProps = ComponentProps<typeof Dialog$1.Close>;
+declare const DialogClose: (props: DialogCloseProps) => React__default.JSX.Element;
 type DialogComponent = ForwardRefExoticComponent<DialogProps & RefAttributes<HTMLDivElement>> & {
     Header: typeof DialogHeader;
     Description: typeof DialogDescription;
     Content: typeof DialogContent;
     Footer: typeof DialogFooter;
+    Trigger: typeof DialogTrigger;
+    Close: typeof DialogClose;
 };
 declare const Dialog: DialogComponent;
 
@@ -1091,7 +1290,7 @@ interface MenuTriggerProps {
     /** Adds to the rendered element. The trigger writes no visual rules of its own. */
     className?: string;
 }
-interface MenuContentProps {
+interface MenuContentProps extends Omit<PartProps<"div">, "children" | "className"> {
     children: ReactNode;
     /** Adds to the popup's own shell. The sheet's material, shape and elevation are the recipe's. */
     className?: string;
@@ -1118,10 +1317,23 @@ interface MenuItemProps {
     disabled?: boolean;
     /** What choosing the action does. The menu closes afterwards; that is Base's contract. */
     onClick?: MouseEventHandler<HTMLDivElement>;
+    /** The row's leading mark. It takes the command icon's slot, beside the label. */
+    icon?: ReactNode;
+    /** The gesture that runs this action elsewhere. It is a hint, and the menu registers no shortcut. */
+    shortcut?: ReactNode;
+    /**
+     * Renders the row as another element, such as a link. Base hands the row's own attributes and its
+     * handlers to that element, so the row keeps its menu behaviour.
+     */
+    render?: ReactElement;
 }
 interface MenuSeparatorProps {
     className?: string;
 }
+/** A group of rows, announced under its label. */
+type MenuGroupProps = PartProps<"div">;
+/** The heading of a group. Base names the group from it, so it is read as the group begins. */
+type MenuLabelProps = PartProps<"div">;
 /**
  * A surface of actions. Each item acts and the menu closes; nothing here holds a value, so a
  * value-selection surface is `Select` or `Combobox` rather than a menu. Base UI owns keyboard
@@ -1137,11 +1349,21 @@ type MenuComponent = ((props: MenuProps) => React__default.JSX.Element) & {
     Content: typeof MenuContent;
     Item: typeof MenuItem;
     Separator: typeof MenuSeparator;
+    Group: typeof MenuGroup;
+    Label: typeof MenuLabel;
 };
-declare const MenuContent: ({ children, className, side, align, sideOffset, alignOffset, }: MenuContentProps) => React__default.JSX.Element;
+declare const MenuContent: ({ children, className, side, align, sideOffset, alignOffset, ...props }: MenuContentProps) => React__default.JSX.Element;
 declare const MenuTrigger: ({ ...props }: MenuTriggerProps) => React__default.JSX.Element;
 declare const MenuItem: {
-    ({ variant, className, children, ...props }: MenuItemProps): React__default.JSX.Element;
+    ({ variant, className, children, icon, shortcut, render, ...props }: MenuItemProps): React__default.JSX.Element;
+    displayName: string;
+};
+declare const MenuGroup: {
+    ({ className, ...props }: MenuGroupProps): React__default.JSX.Element;
+    displayName: string;
+};
+declare const MenuLabel: {
+    ({ className, ...props }: MenuLabelProps): React__default.JSX.Element;
     displayName: string;
 };
 declare const MenuSeparator: ({ className }: MenuSeparatorProps) => React__default.JSX.Element;
@@ -1197,6 +1419,8 @@ declare const Media: {
 interface NavGroupItem {
     label: string;
     href: string;
+    /** The element this destination renders as, such as a router link. It takes precedence over `renderLink`. */
+    render?: ReactElement;
 }
 /** The heading level a group labels itself with. A navigation group owns a real heading, because
  *  that is what makes a column of destinations scannable as groups; which level it is depends on
@@ -1210,17 +1434,28 @@ interface NavGroupProps {
      *  in: a group under a page title is a level 2, one in a sidebar section is whatever its
      *  neighbours are. The default matches the package's other grouped surfaces. */
     headingLevel?: NavGroupHeadingLevel;
+    /**
+     * Renders each destination as the caller's own link, such as a router link. It receives the item and the
+     * row's attributes — the destination, the current marker, the shared classes and the label — the same way
+     * `Breadcrumb` does. An item's own `render` takes precedence over it.
+     */
+    renderLink?: (item: NavGroupItem, props: AnchorHTMLAttributes<HTMLAnchorElement>) => ReactNode;
     className?: string;
 }
-declare const NavGroup: ({ title, items, activeHref, headingLevel, className }: NavGroupProps) => React__default.JSX.Element;
+declare const NavGroup: ({ title, items, activeHref, headingLevel, renderLink, className }: NavGroupProps) => React__default.JSX.Element;
 
 interface NavItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     children: ReactNode;
     href: string;
     icon?: ReactNode;
     active?: boolean;
+    /**
+     * The element the row renders as, such as a router link. The row's classes, its current marker and its
+     * own props are merged onto it, so the link is the row and keeps its own navigation.
+     */
+    render?: ReactElement;
 }
-declare const NavItem: ({ children, icon, className, href, active, ...props }: NavItemProps) => React__default.JSX.Element;
+declare const NavItem: ({ children, icon, className, href, active, render, ...props }: NavItemProps) => React__default.JSX.Element;
 
 interface NumberFieldProps extends Omit<ComponentProps<"input">, "value" | "defaultValue" | "onChange" | "min" | "max" | "step" | "type" | "size" | "ref" | "prefix"> {
     value?: number | null;
@@ -1248,6 +1483,8 @@ interface NumberFieldProps extends Omit<ComponentProps<"input">, "value" | "defa
      * name the unit in the label as well.
      */
     suffix?: ReactNode;
+    /** The field's density: `sm` for a dense filter row, `md` (the default) or `lg`. */
+    size?: FieldSize;
     disabled?: boolean;
     readOnly?: boolean;
     required?: boolean;
@@ -1258,6 +1495,8 @@ interface NumberFieldProps extends Omit<ComponentProps<"input">, "value" | "defa
     inputRef?: Ref<HTMLInputElement>;
     /** Styles the field's own container. The text input is styled through `inputClassName`. */
     className?: string;
+    /** Styles the field's box: the tray that holds the steppers and the value. */
+    fieldClassName?: string;
     inputClassName?: string;
 }
 /**
@@ -1266,6 +1505,19 @@ interface NumberFieldProps extends Omit<ComponentProps<"input">, "value" | "defa
  */
 declare const NumberField: React__default.ForwardRefExoticComponent<NumberFieldProps & React__default.RefAttributes<HTMLInputElement>>;
 
+/** The English copy a pagination names itself and its parts with. Any of it can be replaced. */
+interface PaginationLabels {
+    /** The landmark's accessible name. */
+    navigation: string;
+    /** The accessible name of the step back. */
+    previous: string;
+    /** The accessible name of the step forward. */
+    next: string;
+    /** The accessible name of a page control. */
+    page: (page: number) => string;
+    /** Read before the page total, so the current page reads as "3 of 12". */
+    of: string;
+}
 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;
@@ -1280,12 +1532,20 @@ interface PaginationProps extends Omit<ComponentPropsWithoutRef<"nav">, "childre
     disabled?: boolean;
     /** Renders every available page as a real anchor to the href this returns. */
     getPageHref?: (page: number) => string;
+    /**
+     * Renders each of those anchors as the caller's own link, such as a router link, in place of the plain
+     * anchor. It receives the page and the anchor's props — the href, the accessible name, the shared classes,
+     * the page's content and the activation handler — and it only applies where `getPageHref` gives an href.
+     */
+    renderLink?: (page: number, props: ComponentPropsWithoutRef<"a">) => ReactNode;
     /** 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;
+    /** The English copy the pagination names itself with. The props above take precedence over it. */
+    labels?: Partial<PaginationLabels>;
 }
 declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
 
@@ -1306,7 +1566,13 @@ interface PopoverTriggerProps {
     /** Adds to the rendered element. The trigger writes no visual rules of its own. */
     className?: string;
 }
-interface PopoverContentProps {
+/** The close control of a popover, as Base's own close part. It closes the surface through Base. */
+type PopoverCloseProps = ComponentProps<typeof Popover$1.Close>;
+/** The heading's own `h2`. Base names the popup from it when it is present. */
+type PopoverTitleProps = PartProps<"h2">;
+/** The line under the title, as the element Base wires up as the popup's description. */
+type PopoverDescriptionProps = PartProps<"p">;
+interface PopoverContentProps extends Omit<PartProps<"div">, "children" | "className"> {
     children: ReactNode;
     /** Adds to the popup's own shell. The sheet's material, shape and elevation are the recipe's. */
     className?: string;
@@ -1331,9 +1597,15 @@ interface PopoverContentProps {
 type PopoverComponent = ((props: PopoverProps) => React__default.JSX.Element) & {
     Trigger: typeof PopoverTrigger;
     Content: typeof PopoverContent;
+    Title: typeof PopoverTitle;
+    Description: typeof PopoverDescription;
+    Close: typeof PopoverClose;
 };
 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 PopoverClose: (props: PopoverCloseProps) => React__default.JSX.Element;
+declare const PopoverContent: React__default.ForwardRefExoticComponent<PopoverContentProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const PopoverTitle: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, "ref"> & React__default.RefAttributes<HTMLHeadingElement>>;
+declare const PopoverDescription: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React__default.RefAttributes<HTMLParagraphElement>>;
 declare const Popover: PopoverComponent;
 
 interface ProgressProps extends Omit<ComponentProps<"div">, "children">, Pick<Progress$1.Root.Props, "min" | "max" | "format" | "locale" | "getAriaValueText"> {
@@ -1401,14 +1673,32 @@ interface RadioGroupProps extends Omit<ComponentProps<"div">, "onChange" | "defa
  */
 declare const RadioGroup: React__default.ForwardRefExoticComponent<Omit<RadioGroupProps, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 
-interface SearchProps extends InputHTMLAttributes<HTMLInputElement> {
+interface SearchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
     onSearch: (value: string) => void;
     /** Base's value-change callback, event details included. */
     onValueChange?: Input$1.Props["onValueChange"];
+    /**
+     * The tone of the submit control. It defaults to `secondary`, the neutral tonal control, so the
+     * search field stays quiet beside the page and the one primary action keeps the strong fill.
+     */
     variant?: Variant;
+    /** Waiting for a result: the submit control shows a spinner and cannot be pressed again. */
     loading?: boolean;
     debounceMs?: number;
+    /** Styles the search box itself: the tray that holds the input and its submit control. */
+    className?: string;
+    /** Styles the field's own column, which holds the box, the description and the error. */
+    fieldClassName?: string;
     inputClassName?: string;
+    /** Supporting copy beneath the field. */
+    description?: ReactNode;
+    /**
+     * Marks the field invalid, and a message is shown beneath it. `true` marks it without a message of
+     * its own, so give the field a message that says how to recover.
+     */
+    error?: ReactNode;
+    /** The field's density: `sm` for a dense filter row, `md` (the default) or `lg`. A number is the native `size` attribute. */
+    size?: FieldSize | number;
 }
 declare const Search: React__default.ForwardRefExoticComponent<SearchProps & React__default.RefAttributes<HTMLInputElement>>;
 
@@ -1451,7 +1741,7 @@ interface SegmentedControlProps extends Omit<ComponentProps<"div">, "onChange" |
 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__default.JSX.Element;
+declare const Skeleton: React__default.ForwardRefExoticComponent<SkeletonProps & React__default.RefAttributes<HTMLDivElement>>;
 
 interface SliderProps extends Omit<ComponentProps<"div">, "defaultValue" | "onChange" | "children"> {
     value?: number;
@@ -1486,14 +1776,19 @@ declare const Slider: React__default.ForwardRefExoticComponent<Omit<SliderProps,
 declare const spinnerVariants: (props?: ({
     show?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const loaderVariants: (props?: ({
-    size?: "small" | "medium" | "large" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface SpinnerProps extends VariantProps<typeof spinnerVariants>, VariantProps<typeof loaderVariants> {
-    className?: string;
-    children?: React__default.ReactNode;
+type SpinnerSize = "small" | "medium" | "large" | "sm" | "md" | "lg";
+interface SpinnerProps extends Omit<ComponentPropsWithoutRef<"span">, "children">, VariantProps<typeof spinnerVariants> {
+    /** The loader's size. `sm`, `md` and `lg` are aliases of `small`, `medium` and `large`. */
+    size?: SpinnerSize | null;
+    /**
+     * What the work is, read to a screen reader. A spinner with a label, or with visible children, is a status
+     * that announces itself. A spinner with neither is decoration, and assistive technology skips it.
+     */
+    label?: string;
+    /** Visible copy beside the loader. */
+    children?: ReactNode;
 }
-declare function Spinner({ size, show, children, className }: SpinnerProps): React__default.JSX.Element;
+declare const Spinner: React__default.ForwardRefExoticComponent<SpinnerProps & React__default.RefAttributes<HTMLSpanElement>>;
 
 interface StepperItem {
     value: string;
@@ -1517,6 +1812,8 @@ interface StepperProps extends Omit<ComponentProps<"nav">, "children" | "default
     /** Horizontal when the container has room; otherwise the same sequence stacks vertically. */
     orientation?: "horizontal" | "vertical";
     disabled?: boolean;
+    /** The name a completed step's mark carries for a screen reader. Defaults to `Complete`. */
+    completeLabel?: string;
 }
 declare const Stepper: React__default.ForwardRefExoticComponent<Omit<StepperProps, "ref"> & React__default.RefAttributes<HTMLElement>>;
 
@@ -1535,9 +1832,17 @@ interface SwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "val
 declare const Switch: React__default.ForwardRefExoticComponent<SwitchProps & React__default.RefAttributes<HTMLButtonElement>>;
 
 type TabsChangeDetails = Parameters<NonNullable<Tabs$1.Root.Props["onValueChange"]>>[1];
+/** The English copy a tab list names itself with. */
+interface TabsLabels {
+    /** The tab list's accessible name, when neither `aria-label` nor `aria-labelledby` names it. */
+    list: string;
+}
 interface Tab {
     id: string;
-    label: string;
+    /** The tab's name. The tab is named by its label, so the label may be any content a row can hold. */
+    label: ReactNode;
+    /** A mark before the label. It is decorative: the label alone names the tab. */
+    icon?: ReactNode;
     content: ReactNode;
     disabled?: boolean;
 }
@@ -1549,9 +1854,16 @@ interface TabsProps {
     defaultValue?: string;
     /** Base's value-change event details are passed through unchanged. */
     onValueChange?: (tabId: string, eventDetails: TabsChangeDetails) => void;
+    /** Names the tab list. Left unset, the list takes the name in `labels`. */
+    "aria-label"?: string;
+    /** Names the tab list from an element that already labels it. It takes precedence over a name. */
+    "aria-labelledby"?: string;
+    /** The same name as `aria-label`, kept for callers that already use it. */
     ariaLabel?: string;
+    /** The English copy the tab list names itself with. */
+    labels?: Partial<TabsLabels>;
 }
-declare const Tabs: ({ tabs, variant, className, value, defaultValue, onValueChange, ariaLabel, }: TabsProps) => React__default.JSX.Element | null;
+declare const Tabs: ({ tabs, variant, className, value, defaultValue, onValueChange, "aria-label": ariaLabelProp, "aria-labelledby": ariaLabelledBy, ariaLabel, labels, }: 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. */
@@ -1584,27 +1896,46 @@ type ToggleGroupComponent = ForwardRefExoticComponent<ToggleGroupProps & RefAttr
  */
 declare const ToggleGroup: ToggleGroupComponent;
 
-interface TableProps {
-    headers: Array<string | TableColumn>;
-    rows: ReactNode[][];
-    /** Classes for the outer scrollable surface. */
-    className?: string;
-    /** Classes for the native table element. */
-    tableClassName?: string;
-}
 interface TableColumn {
     /** Stable identity for this column, shared by its header and body cells. */
     id: string;
     label: string;
     /** Classes applied to this column's header and body cells. */
     className?: string;
+    /**
+     * The column names each row, so its body cells are row headers (`th scope="row"`) rather than data.
+     * A row header is what a screen reader announces with every cell beside it.
+     */
+    rowHeader?: boolean;
 }
-declare const Table: ({ headers, rows, className, tableClassName, }: TableProps) => React__default.JSX.Element;
+interface TableProps extends Omit<ComponentPropsWithoutRef<"div">, "children" | "role"> {
+    headers: Array<string | TableColumn>;
+    rows: ReactNode[][];
+    /**
+     * The table's visible caption. A string caption also names the scrolling region, so a table with a
+     * caption is never anonymous.
+     */
+    caption?: ReactNode;
+    /** The one row shown when `rows` is empty, spanning every column. */
+    emptyMessage?: ReactNode;
+    /** A stable key for each row. The index is only right for rows that never reorder. */
+    getRowKey?: (row: ReactNode[], index: number) => Key;
+    /** Classes for the outer scrollable surface. */
+    className?: string;
+    /** Classes for the native table element. */
+    tableClassName?: string;
+}
+declare const Table: React__default.ForwardRefExoticComponent<TableProps & React__default.RefAttributes<HTMLDivElement>>;
 
 interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     label?: ReactNode;
     description?: ReactNode;
-    error?: boolean;
+    /**
+     * Marks the field invalid. A message is shown beneath it, so a `ReactNode` here is both the flag and
+     * its message. `true` marks the field without one, and `errorMessage` supplies the message.
+     */
+    error?: ReactNode;
+    /** The message for `error={true}`. A message passed as `error` takes its place. */
     errorMessage?: ReactNode;
     textareaClassName?: string;
     /** Base's value-change callback, event details included. */
@@ -1613,12 +1944,31 @@ interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
 declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
 
 interface TooltipProps {
+    /** The trigger. The hint attaches to this element directly: no wrapper is rendered around it. */
     children: ReactElement;
     content: ReactNode;
+    /** Adds to the trigger element. */
     className?: string;
     position?: "top" | "right" | "bottom" | "left";
+    /** Where the hint sits along its edge. */
+    align?: OverlayAlign;
 }
-declare const Tooltip: ({ children, content, className, position }: TooltipProps) => React__default.JSX.Element;
+interface TooltipProviderProps {
+    children: ReactNode;
+    /** How long a hint waits on hover before it opens, in milliseconds. */
+    delay?: number;
+    /** How long a hint waits before it closes, in milliseconds. */
+    closeDelay?: number;
+    /** A hint opened within this window after another closes opens at once. Base's own default is 400ms. */
+    timeout?: number;
+}
+/**
+ * Shares one warm-up across every tooltip beneath it. Hovering a hint opens it after its delay; once a
+ * hint closes, the next one opens at once while the pointer stays in the group. Four adjacent icon
+ * buttons therefore show their hints without a wait each time.
+ */
+declare const TooltipProvider: ({ children, delay, closeDelay, timeout }: TooltipProviderProps) => React__default.JSX.Element;
+declare const Tooltip: ({ children, content, className, position, align }: TooltipProps) => React__default.JSX.Element;
 
 /**
  * The finite static tree a `TreeView` presents.
@@ -1684,13 +2034,6 @@ interface TreeViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"
  */
 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
- * into the middle of the viewport and takes the modal presence. Every other value is a sheet
- * attached to that edge of the viewport, and slides out of it.
- */
-type DialogAttachment = "center" | "bottom" | "top" | "left" | "right";
-
 /**
  * The viewport edge a sheet is attached to. Sides are **physical** rather than logical: the
  * contract places the sheet against that edge of the screen rather than resolving a writing
@@ -1706,6 +2049,8 @@ interface DrawerProps {
     onOpenChange?: Dialog$1.Root.Props["onOpenChange"];
     /** The edge the sheet is attached to. */
     side?: DrawerSide;
+    /** The accessible name of the sheet's dismissal control. Defaults to "Close". */
+    closeLabel?: string;
 }
 interface DrawerTriggerProps {
     /**
@@ -1717,23 +2062,14 @@ interface DrawerTriggerProps {
     /** Adds to the rendered element. The trigger writes no visual rules of its own. */
     className?: string;
 }
-interface DrawerContentProps {
-    children: ReactNode;
-    /** Adds to the sheet's own surface. Its shell, elevation and presence are the recipe's. */
-    className?: string;
-}
-interface DrawerHeaderProps {
-    children: ReactNode;
-    className?: string;
-}
-interface DrawerDescriptionProps {
-    children: ReactNode;
-    className?: string;
-}
-interface DrawerFooterProps {
-    children: ReactNode;
-    className?: string;
-}
+/** The sheet's own surface element: the popup, which takes the rest props and the ref. */
+type DrawerContentProps = PartProps<"div">;
+/** The header's own `div`. */
+type DrawerHeaderProps = PartProps<"div">;
+/** The supporting line's own `p`. */
+type DrawerDescriptionProps = PartProps<"p">;
+/** The footer's own `div`. */
+type DrawerFooterProps = PartProps<"div">;
 type DrawerComponent = ((props: DrawerProps) => React__default.JSX.Element) & {
     Trigger: typeof DrawerTrigger;
     Content: typeof DrawerContent;
@@ -1753,10 +2089,10 @@ declare const DrawerTrigger: ({ ...props }: DrawerTriggerProps) => React__defaul
  * 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__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 DrawerContent: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DrawerHeader: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
+declare const DrawerDescription: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & React__default.RefAttributes<HTMLParagraphElement>>;
+declare const DrawerFooter: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React__default.RefAttributes<HTMLDivElement>>;
 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
@@ -1797,7 +2133,11 @@ interface ToastOptions {
     type?: ToastType;
     title?: ReactNode;
     description?: ReactNode;
-    /** How long it stays before dismissing itself. `0` keeps it until it is dismissed. */
+    /**
+     * How long it stays before dismissing itself. `0` keeps it until it is dismissed. Left unset, a
+     * toast with an action or a `danger` type is sticky: its action is a decision to make and its
+     * danger is one to acknowledge, so it waits. Any other toast keeps the provider's timeout.
+     */
     timeout?: number;
     /** How urgently it is announced. `high` interrupts rather than waiting its turn. */
     priority?: "low" | "high";
@@ -1847,9 +2187,27 @@ interface ToastProviderProps {
     /** A manager built with `createToastManager`, for raising a toast from outside React. */
     manager?: ToastManager;
 }
+/**
+ * The words a toast gives its own status when it has no title, so an assistive technology can name it.
+ * Each one is the English default, and each can be replaced with the application's own wording.
+ */
+interface ToastLabels {
+    info: string;
+    success: string;
+    warning: string;
+    danger: string;
+    error: string;
+    loading: string;
+    /** The name of a toast that reports no type this library knows. */
+    notification: string;
+}
 interface ToastViewportProps {
     /** The corner the stack grows from. It is also the edge a toast enters and leaves through. */
     position?: ToastPosition;
+    /** The accessible name of every toast's dismissal control. Defaults to "Dismiss". */
+    dismissLabel?: string;
+    /** The words a toast without a title is named by, one per status. Each one overrides its English default. */
+    labels?: Partial<ToastLabels>;
     /** Adds to the viewport's own layer. The toasts style themselves. */
     className?: string;
 }
@@ -1869,7 +2227,7 @@ declare const ToastProvider: ({ children, manager, ...props }: ToastProviderProp
  * 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__default.JSX.Element;
+declare const ToastViewport: ({ position, dismissLabel, labels, 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.
@@ -1890,5 +2248,5 @@ interface DirectionProviderProps {
 /** Declares writing direction to the interaction and positioning primitives, including portals. */
 declare const DirectionProvider: ({ direction, children }: DirectionProviderProps) => React__default.JSX.Element;
 
-export { Accordion, Alert, AlertDialog, Avatar, Badge, Breadcrumb, Button, Calendar, Card, Checkbox, CheckboxGroup, Chip, ChipGroup, Collapsible, Combobox, Command, CommandPalette, DatePicker, DateRangePicker, DateTimePicker, Dialog, DirectionProvider, Divider, Drawer, Field, FileUpload, Form, 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, CalendarDateTime, CalendarLabels, CalendarProps, CardProps, CheckboxGroupOption, CheckboxGroupProps, CheckboxProps, ChipGroupProps, ChipProps, CollapsiblePanelProps, CollapsibleProps, CollapsibleTriggerProps, ComboboxMultipleProps, ComboboxOption, ComboboxOptionGroup, ComboboxPasteDetails, ComboboxProps, ComboboxSingleProps, CommandItem, CommandPaletteProps, CommandProps, DatePickerProps, DateRange, DateRangePickerProps, DateTimePickerLabels, DateTimePickerProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogProps, DirectionProviderProps, DividerProps, DividerWeight, DrawerContentProps, DrawerDescriptionProps, DrawerFooterProps, DrawerHeaderProps, DrawerProps, DrawerSide, DrawerTriggerProps, FieldProps, FileRejection, FileUploadProps, FormErrors, FormProps, 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, SelectOptionGroup, SelectProps, SkeletonProps, SliderProps, SpinnerProps, StepperItem, StepperProps, SwitchProps, Tab, TableColumn, TableProps, TabsProps, TextareaProps, ToastActionOptions, ToastManager, ToastOptions, ToastPosition, ToastPromiseOptions, ToastProviderProps, ToastType, ToastUpdateOptions, ToastViewportProps, ToggleGroupItemProps, ToggleGroupProps, TooltipProps, TreeViewItem, TreeViewProps, Variant };
+export { Accordion, Alert, AlertDialog, Avatar, Badge, Breadcrumb, Button, Calendar, Card, Checkbox, CheckboxGroup, Chip, ChipGroup, Collapsible, Combobox, Command, CommandPalette, DatePicker, DateRangePicker, DateTimePicker, Dialog, DirectionProvider, Divider, Drawer, Field, FileUpload, Form, 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, TooltipProvider, TreeView, createToastManager, useToast };
+export type { AccordionHeadingLevel, AccordionItemProps, AccordionPanelProps, AccordionProps, AccordionTriggerProps, AlertDialogProps, AlertDialogTriggerProps, AlertProps, AvatarProps, BadgeProps, BreadcrumbItem, BreadcrumbLabels, BreadcrumbProps, ButtonAppearance, ButtonProps, ButtonSize, CalendarDate, CalendarDateTime, CalendarLabels, CalendarProps, CardDescriptionProps, CardProps, CardTitleProps, CheckboxGroupOption, CheckboxGroupProps, CheckboxProps, ChipGroupProps, ChipProps, ChoiceAppearance, CollapsiblePanelProps, CollapsibleProps, CollapsibleTriggerProps, ComboboxLabels, ComboboxMultipleProps, ComboboxOption, ComboboxOptionGroup, ComboboxPasteDetails, ComboboxProps, ComboboxSingleProps, CommandItem, CommandLabels, CommandPaletteProps, CommandProps, DatePickerProps, DateRange, DateRangePickerProps, DateTimePickerLabels, DateTimePickerProps, DialogAttachment, DialogCloseProps, DialogContentProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogProps, DialogTriggerProps, DirectionProviderProps, DividerProps, DividerWeight, DrawerContentProps, DrawerDescriptionProps, DrawerFooterProps, DrawerHeaderProps, DrawerProps, DrawerSide, DrawerTriggerProps, FieldProps, FieldSize, FileRejection, FileUploadLabels, FileUploadProps, FormErrors, FormProps, IconButtonAppearance, IconButtonProps, IconButtonSize, InputProps, MediaImageProps, MediaVideoProps, MenuContentProps, MenuGroupProps, MenuItemProps, MenuLabelProps, MenuProps, MenuSeparatorProps, MenuTriggerProps, NavGroupHeadingLevel, NavGroupItem, NavGroupProps, NavItemProps, NumberFieldProps, OverlayAlign, OverlaySide, PaginationLabels, PaginationProps, PartProps, PopoverCloseProps, PopoverContentProps, PopoverDescriptionProps, PopoverProps, PopoverTitleProps, PopoverTriggerProps, ProgressProps, RadioGroupOption, RadioGroupProps, SearchProps, SegmentedControlOption, SegmentedControlProps, SelectOption, SelectOptionGroup, SelectProps, SkeletonProps, SliderProps, SpinnerProps, StepperItem, StepperProps, SwitchProps, Tab, TableColumn, TableProps, TabsLabels, TabsProps, TextareaProps, ToastActionOptions, ToastLabels, ToastManager, ToastOptions, ToastPosition, ToastPromiseOptions, ToastProviderProps, ToastType, ToastUpdateOptions, ToastViewportProps, ToggleGroupItemProps, ToggleGroupProps, TooltipProps, TooltipProviderProps, TreeViewItem, TreeViewProps, TriggerProps, Variant };