prime-ui-kit 0.15.0 → 0.17.0

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

@@ -4,43 +4,83 @@ export type SliderLabels = {
     /** Muted marker after the label when `optional`. */
     optional: string;
 };
-export type SliderProps = FieldRootDomProps & Omit<FieldFrameProps, "focusRing"> & {
+export declare const SLIDER_LABELS: SliderLabels;
+export type SliderProps = FieldRootDomProps & FieldFrameProps & {
+    /**
+     * Controlled value; clamped to `min`…`max`.
+     */
     value?: number;
+    /**
+     * Initial value when uncontrolled.
+     */
     defaultValue?: number;
+    /**
+     * Called with the new number while dragging and on every key step.
+     */
     onValueChange?: (value: number) => void;
     /**
-     * The value the person settled on: fires once when the thumb is released (pointer) or after a
-     * key moved it, and only if the value differs from the last commit. Save here instead of on
-     * every `onValueChange` step. Return the save's promise: the thumb dims (`aria-busy`) until it
-     * settles; reject — the value glides back to the last saved one.
+     * The value the person settled on, once after a drag or a key step. Save here, not in `onValueChange`. Return the save's promise: the thumb dims until it settles; on reject the value goes back.
      */
     onCommit?: (value: number) => void | Promise<void>;
-    /** Name of the range input, submitted with a form. */
+    /**
+     * Name of the range input, submitted with a form.
+     */
     name?: string;
+    /**
+     * Lower bound.
+     */
     min?: number;
+    /**
+     * Upper bound.
+     */
     max?: number;
+    /**
+     * Step of the keyboard and of the snapping; fractions allowed.
+     */
     step?: number;
+    /**
+     * Muted track and thumb, dimmed label and value, no interaction.
+     */
     disabled?: boolean;
-    /** Invalid state: `aria-invalid` on the range input. A non-empty `error` implies it. */
+    /**
+     * `aria-invalid` on the range input, a danger fill (over any `tone`) and a danger focus ring on the thumb. A non-empty `error` implies it.
+     */
     invalid?: boolean;
-    /** Shows the current value at the end of the label row (tabular numbers). */
+    /**
+     * Shows the current value at the end of the label row (tabular numbers, `aria-hidden` — the input announces it).
+     */
     showValue?: boolean;
-    /** Formats the displayed value and `aria-valuetext` (e.g. `(v) => \`${v} °C\``). */
+    /**
+     * Formats the shown value and `aria-valuetext` (units, currency).
+     */
     formatValue?: (value: number) => string;
-    /** Tier. Default: the tier of the surrounding control (a form, a panel), else `m`. */
+    /**
+     * Tier of the track thickness T (thumb 4.5T × 3T), the label, the value and the hint. Without it the tier of its host (a form, a panel), else `m`.
+     */
     size?: ControlSize;
-    /** Color of the filled part of the track. */
+    /**
+     * Color of the filled part of the track.
+     */
     tone?: Tone;
     /**
-     * `vertical` — the track stands upright, minimum at the bottom, seven thumbs long at its tier
-     * (a level beside a button). Default `horizontal`.
+     * `vertical` — the track stands upright, minimum at the bottom: a level beside a button, a mixer column.
      */
     orientation?: "horizontal" | "vertical";
-    /** Id of the range input; generated when omitted. */
+    /**
+     * Id of the range input (generated when omitted); hint id is `<id>-hint`, error id is `<id>-error`.
+     */
     id?: string;
-    /** Name of the range input when there is no `label`. */
+    /**
+     * Accessible name when there is no visible `label`.
+     */
     "aria-label"?: string;
+    /**
+     * Merged before the hint / error ids on the range input.
+     */
     "aria-describedby"?: string;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<SliderLabels>;
 };
 /**

package/dist/components/smart-filter/SmartFilter.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import type { ControlSize } from "../../internal/states";
+import { type ControlSize } from "../../internal/states";
 import { type SmartFilterValue } from "./model";
 export type { SmartFilterFieldValue, SmartFilterMode, SmartFilterRange, SmartFilterSelection, SmartFilterValue, } from "./model";
 export { isSmartFilterRange, matchesSmartFilter, resolveSmartFilterValues } from "./model";
@@ -96,39 +96,65 @@ export type SmartFilterLabels = {
     /** Chip value of a range with only the upper bound. */
     rangeTo: string;
 };
+export declare const SMART_FILTER_LABELS: SmartFilterLabels;
 export type SmartFilterRootProps = {
-    /** The fields this screen filters by, in display order. Empty: only the search remains. */
+    /**
+     * Fields of this screen, in display order; empty — only the search. Pass a stable reference.
+     */
     fields: readonly SmartFilterField[];
-    /** Value per field key: a selection, or the bounds of a range field. */
+    /**
+     * Value per field key, controlled: `{ include, exclude }` for an options field, `{ from, to }` (numbers or dates, `null` — open) for a range field.
+     */
     value?: SmartFilterValue;
+    /**
+     * Initial selection, uncontrolled.
+     */
     defaultValue?: SmartFilterValue;
+    /**
+     * The whole next value; keys of fields this root does not show are kept.
+     */
     onValueChange?: (value: SmartFilterValue) => void;
-    /** Free-text search. Applied as typed; debounce it in the owner if needed. */
+    /**
+     * Search text, controlled.
+     */
     search?: string;
+    /**
+     * Initial search text, uncontrolled.
+     */
     defaultSearch?: string;
+    /**
+     * Every keystroke; debounce in the owner when it asks a server.
+     */
     onSearchChange?: (search: string) => void;
+    /**
+     * Tier of the filter button, the search, the tags and the panel. Without it the tier of its host, else `m`.
+     */
     size?: ControlSize;
-    /** Values of one field shown before «Ещё N». Default 12. */
+    /**
+     * Values of one field shown before «Ещё N» (not while searching).
+     */
     collapsedLimit?: number;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<SmartFilterLabels>;
-    className?: string;
-    /** `SmartFilter.Toolbar` and `SmartFilter.Chips`. */
+    /**
+     * `SmartFilter.Toolbar` and `SmartFilter.Chips`, anywhere inside — in a page bar the Root wraps `Page.Root`.
+     */
     children: React.ReactNode;
-    ref?: React.Ref<HTMLDivElement>;
 };
-declare function SmartFilterRoot({ fields, value, defaultValue, onValueChange, search, defaultSearch, onSearchChange, size, collapsedLimit, labels, className, children, ref, }: SmartFilterRootProps): import("react/jsx-runtime").JSX.Element;
+declare function SmartFilterRoot({ fields, value, defaultValue, onValueChange, search, defaultSearch, onSearchChange, size: sizeProp, collapsedLimit, labels, children, }: SmartFilterRootProps): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
 declare namespace SmartFilterRoot {
     var displayName: string;
 }
 export type SmartFilterToolbarProps = Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & {
     /**
-     * The search input (default `true`). `false` — the filter button alone, for a screen whose
-     * text search lives elsewhere or does not exist.
+     * The search input. `false` — the filter button alone; the panel opens at its own width (24rem at most) and lists every field.
      */
     searchable?: boolean;
     ref?: React.Ref<HTMLDivElement>;
 };
-declare function SmartFilterToolbar({ searchable, className, ...rest }: SmartFilterToolbarProps): import("react/jsx-runtime").JSX.Element;
+declare function SmartFilterToolbar({ searchable, className, ref, ...rest }: SmartFilterToolbarProps): import("react/jsx-runtime").JSX.Element;
 declare namespace SmartFilterToolbar {
     var displayName: string;
 }
@@ -136,7 +162,7 @@ export type SmartFilterChipsProps = Omit<React.HTMLAttributes<HTMLDivElement>, "
     ref?: React.Ref<HTMLDivElement>;
 };
 /** The applied filters as removable tags, with "add" and "clear all". Renders nothing without filters. */
-declare function SmartFilterChips({ className, ...rest }: SmartFilterChipsProps): import("react/jsx-runtime").JSX.Element | null;
+declare function SmartFilterChips({ className, ref, ...rest }: SmartFilterChipsProps): import("react/jsx-runtime").JSX.Element | null;
 declare namespace SmartFilterChips {
     var displayName: string;
 }

package/dist/components/sparkline/Sparkline.d.ts

@@ -38,55 +38,78 @@ export type SparklineSummary = "latest" | "sum" | "average";
  * the height of an `xs` control, for a table cell or a list row.
  */
 export type SparklineLayout = "default" | "compact";
+export declare const SPARKLINE_LABELS: SparklineLabels;
 type SparklineRest = {
-    /** Default `latest`. */
+    /**
+     * What the headline shows at rest: `latest` — the latest point (or `highlight`), for a level (MRR, conversion); `sum` — the period total, for a flow (revenue per day); `average` — the period mean.
+     */
     summary?: "latest";
     /**
-     * Index of the point at rest (the current month): the headline shows it when nobody scrubs,
-     * and `bars` draw the other bars quieter. Default: the latest point with a value.
+     * Index of the point at rest with `summary="latest"` (the current month): the headline returns to it; `bars` draw the other bars quieter. Not allowed with `sum` / `average`.
      */
     highlight?: number;
 } | {
+    /**
+     * What the headline shows at rest: `latest` — the latest point (or `highlight`), for a level (MRR, conversion); `sum` — the period total, for a flow (revenue per day); `average` — the period mean.
+     */
     summary: "sum" | "average";
-    /** A total or a mean is no point: there is nothing to highlight at rest. */
+    /**
+     * Index of the point at rest with `summary="latest"` (the current month): the headline returns to it; `bars` draw the other bars quieter. Not allowed with `sum` / `average`.
+     */
     highlight?: never;
 };
 export type SparklineProps = Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & SparklineRest & {
-    /** Points in order, oldest first; two present points in a row draw a line. */
+    /**
+     * Points oldest first, `{ label, value }`; `label` names the point («8 окт»), `value: null` is a point with no data — the line breaks, the bar is absent. A new array cross-fades the chart in.
+     */
     data: SparklinePoint[];
     /**
-     * Visible title above the value and the accessible name of the chart; with `layout="compact"`
-     * only the accessible name.
+     * Visible title above the value and the accessible name of the chart; with `layout="compact"` only the accessible name.
      */
     label: string;
-    /** Default `area`. */
+    /**
+     * `area` — a line over an accent gradient that fades to the bottom; `line` — the line alone, for many trends side by side; `bars` — a bar per point standing on a zero line: up when positive, down (danger) when negative.
+     */
     variant?: SparklineVariant;
-    /** Shape of the line between points (`area`, `line`). Default `smooth`. */
+    /**
+     * Shape of the line (`area`, `line`): `smooth` — a monotone cubic through every point that never overshoots a peak or a trough; `linear` — straight segments; `step` — a level per point, changing halfway between points.
+     */
     curve?: SparklineCurve;
-    /** Default `default`. */
+    /**
+     * `default` — the headline over an 80 px plot; `compact` — the plot alone at an `xs` control height with the dot at rest, for a DataTable cell; the scrubbed point shows in the tooltip and `aria-valuetext`.
+     */
     layout?: SparklineLayout;
-    /** What a scrubbed point's change badge compares with. Default `previous`. */
+    /**
+     * What the change badge of a shown point compares it with: `previous` — the point before it; `first` — the first point with a value (the change over the period); `none` — no badge.
+     */
     change?: SparklineChange;
     /**
-     * The same summary for the previous period («прошлые 30 дней»): the change badge at rest compares
-     * the headline with it. Without it a `sum` / `average` headline shows no change at rest.
+     * The same summary for the previous period («прошлые 30 дней»): the badge at rest compares the headline with it. Without it a `sum` / `average` headline shows no change at rest.
      */
     compareTo?: number;
     /**
-     * The value axis spans at least `min`…`max`: one scale for several sparklines (a table column)
-     * or a meaningful floor. Data outside widens the scale, never gets cut.
+     * The value axis reaches down to at least this value: a floor of zero, or one scale for several sparklines (a table column). Data below widens the scale, never gets cut.
      */
     min?: number;
+    /**
+     * The value axis reaches up to at least this value; data above widens the scale.
+     */
     max?: number;
-    /** A dashed horizontal line at this value: a plan, a target, an average. */
+    /**
+     * A dashed horizontal line at this value — a plan, a target, an average; the scale holds it and the chart is described by `labels.reference`.
+     */
     reference?: number;
     /**
-     * The series is on its way: Skeletons of the value, the date and the plot, which cross-fade into
-     * the data. The title stays; the root is `aria-busy`.
+     * The series is on its way: Skeletons of the date, the value and the plot that cross-fade into the data; the title stays, the root is `aria-busy` and the chart is not focusable yet.
      */
     loading?: boolean;
-    /** Display of a value («312 400 ₽»). Default: the number with Russian digit groups. */
+    /**
+     * Display of a value in the headline, the tooltip, the reference description and the spoken point («312 400 ₽»).
+     */
     formatValue?: (value: number) => string;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<SparklineLabels>;
     ref?: React.Ref<HTMLDivElement>;
 };

package/dist/components/spinner/Spinner.d.ts

@@ -1,23 +1,29 @@
-import * as React from "react";
+import type * as React from "react";
 import type { ControlSize, TextTone } from "../../internal/states";
 export type SpinnerLabels = {
     /** Text read by screen readers while the spinner is shown. */
     loading: string;
 };
+export declare const SPINNER_LABELS: SpinnerLabels;
 export type SpinnerProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
     /**
-     * Explicit size on the icon scale (xs 14 · s 16 · m 20 · l 24 · xl 32). Without it the spinner
-     * follows its host like an `Icon`: the host's icon size, else the nearest control tier, else 16.
+     * Explicit size on the icon scale: 14 · 16 · 20 · 24 · 32. Without it the spinner follows its host like `Icon`: the host's `--prime-icon-size`, else the nearest control tier, else 16.
      */
     size?: ControlSize;
-    /** Ring color; `default` inherits `currentColor`. */
+    /**
+     * Ring color; `default` inherits `currentColor`.
+     */
     tone?: TextTone;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<SpinnerLabels>;
     ref?: React.Ref<HTMLSpanElement>;
 };
 /**
  * Indeterminate loading indicator: the kit ring (`internal/ring`) with the share unknown — a quarter
  * arc turning on a faint track, at the line weight. A `role="status"` region with `labels.loading`
- * for screen readers; pass `aria-hidden` when the host already says it is busy.
+ * for screen readers; pass `aria-hidden` when the host already says it is busy. It fades itself in
+ * (`enterMotion.enterFade`), so a host that shows it conditionally needs no motion of its own.
  */
 export declare function Spinner({ size: sizeProp, tone, labels: labelsProp, className, ...rest }: SpinnerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/stepper/Stepper.d.ts

@@ -1,25 +1,54 @@
 import * as React from "react";
 import type { ControlSize } from "../../internal/states";
-/** Item state: derived from the Root `value` (before → `completed`, equal → `active`, after → `pending`) unless set on the item. */
-export type StepperItemStatus = "pending" | "active" | "completed" | "danger";
+/** Item state: derived from the Root `value` (before → `completed`, equal → `current`, after → `pending`) unless set on the item. */
+export type StepperItemStatus = "pending" | "current" | "completed" | "danger";
+export type StepperLabels = {
+    /** Spoken after the name of a completed step (the check is only seen). */
+    completed: string;
+    /** Spoken after the name of a step that needs attention (the colour and the glyph are only seen). */
+    danger: string;
+};
+export declare const STEPPER_LABELS: StepperLabels;
+type StepperOrientation = "horizontal" | "vertical";
 export type StepperRootProps = Omit<React.OlHTMLAttributes<HTMLOListElement>, "defaultValue" | "onChange"> & {
-    /** Default `vertical`. A horizontal stepper stacks vertically in containers narrower than 480px. */
-    orientation?: "horizontal" | "vertical";
-    /** Current step (0-based), controlled. */
+    /**
+     * Column of rows, or one row with chevrons (steps shrink and wrap their titles) that stacks below a 480px container.
+     */
+    orientation?: StepperOrientation;
+    /**
+     * Current step, 0-based (controlled).
+     */
     value?: number;
-    /** Initial step when uncontrolled. Default `0`. */
+    /**
+     * Initial step (uncontrolled).
+     */
     defaultValue?: number;
-    /** Called with the item index when an item is clicked. */
+    /**
+     * Called with the index of the clicked item.
+     */
     onValueChange?: (index: number) => void;
+    /**
+     * Every vertical row ends with a chevron: each step opens a page or panel. Horizontal steps already have their chevrons.
+     */
+    arrows?: boolean;
+    /**
+     * Indicator 20 · 24 · 28 · 32 · 36, title in the control text of the tier. Without it the tier of its host, else `m`.
+     */
     size?: ControlSize;
+    /**
+     * Built-in strings, see Labels.
+     */
+    labels?: Partial<StepperLabels>;
     ref?: React.Ref<HTMLOListElement>;
 };
-declare function StepperRoot({ orientation, value: valueProp, defaultValue, onValueChange, size, children, className, ...rest }: StepperRootProps): import("react/jsx-runtime").JSX.Element;
+declare function StepperRoot({ orientation, value: valueProp, defaultValue, onValueChange, arrows, size: sizeProp, labels: labelsProp, children, className, ...rest }: StepperRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace StepperRoot {
     var displayName: string;
 }
 export type StepperItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
-    /** Overrides the status derived from the Root `value` (e.g. `danger`). */
+    /**
+     * Overrides the status derived from `value` (before → `completed`, equal → `current`, after → `pending`).
+     */
     status?: StepperItemStatus;
     ref?: React.Ref<HTMLButtonElement>;
 };
@@ -31,7 +60,9 @@ type SpanProps = React.HTMLAttributes<HTMLSpanElement> & {
     ref?: React.Ref<HTMLSpanElement>;
 };
 export type StepperIndicatorProps = SpanProps & {
-    /** Replaces the default content (the item number, or a check when completed). */
+    /**
+     * Replaces the default content, e.g. `<Icon name="status.info" />`.
+     */
     children?: React.ReactNode;
 };
 declare function StepperIndicator({ children, className, ...rest }: StepperIndicatorProps): import("react/jsx-runtime").JSX.Element;
@@ -54,14 +85,6 @@ declare function StepperDescription({ className, ...rest }: StepperDescriptionPr
 declare namespace StepperDescription {
     var displayName: string;
 }
-export type StepperArrowProps = Omit<React.SVGAttributes<SVGSVGElement>, "children" | "color"> & {
-    ref?: React.Ref<SVGSVGElement>;
-};
-/** Trailing chevron for vertical items that open a page or panel. */
-declare function StepperArrow({ className, ...rest }: StepperArrowProps): import("react/jsx-runtime").JSX.Element;
-declare namespace StepperArrow {
-    var displayName: string;
-}
 export declare const Stepper: {
     Root: typeof StepperRoot;
     Item: typeof StepperItem;
@@ -69,6 +92,5 @@ export declare const Stepper: {
     Content: typeof StepperContent;
     Title: typeof StepperTitle;
     Description: typeof StepperDescription;
-    Arrow: typeof StepperArrow;
 };
 export {};

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

@@ -1,34 +1,59 @@
 import type * as React from "react";
 import { type ChoiceLabelProps } from "../../internal/ChoiceField";
 import type { ControlSize } from "../../internal/states";
+export type SwitchLabels = {
+    /** Muted marker after the label text when `optional`. */
+    optional: string;
+};
+export declare const SWITCH_LABELS: SwitchLabels;
 export type SwitchRootProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "checked" | "defaultChecked" | "onChange"> & {
+    /**
+     * Controlled state.
+     */
     checked?: boolean;
+    /**
+     * Initial state when uncontrolled.
+     */
     defaultChecked?: boolean;
     /**
-     * The new state. Return the save's promise to apply it on a server: the thumb waits in the new
-     * position with a spinner (`aria-busy`) and presses do nothing; resolve keeps it, reject glides
-     * it back.
+     * Called with the new state on every toggle. Return the save's promise: the thumb waits with a spinner; a controlled owner sets `checked` before resolving; on reject the thumb goes back (say why with `error`).
      */
     onCheckedChange?: (checked: boolean) => void | Promise<void>;
     /**
-     * Saving: a spinner in the thumb, `aria-busy`, presses do nothing. For an owner that tracks the
-     * request itself; a promise from `onCheckedChange` does this on its own.
+     * Saving, for an owner that tracks the request itself: a spinner in the thumb, `aria-busy` on the input, presses do nothing. A promise from `onCheckedChange` does the same on its own.
      */
     loading?: boolean;
-    /** Invalid state; a non-empty `error` implies it. */
+    /**
+     * Danger ring on the off track and `aria-invalid`. A non-empty `error` implies it.
+     */
     invalid?: boolean;
-    /** Help text under the label text. Hidden while `error` is shown. */
+    /**
+     * Help text under the label text. Hidden while `error` is shown.
+     */
     hint?: React.ReactNode;
-    /** Error message in the hint slot; implies `invalid`. */
+    /**
+     * Error message in the hint slot; implies `invalid`.
+     */
     error?: React.ReactNode;
-    /** Tier. Default: the tier of the surrounding control (a form, a panel), else `m`. */
+    /**
+     * Tier of the track (24×16 … 44×24), the text and the gap. Without it the tier of its host (a form, a panel), else `m`.
+     */
     size?: ControlSize;
-    /** `Switch.Label`; without it only the track renders (give it an `aria-label`). */
+    /**
+     * Muted `labels.optional` after the label text; the field may stay off.
+     */
+    optional?: boolean;
+    /**
+     * Built-in strings, see Labels.
+     */
+    labels?: Partial<SwitchLabels>;
+    /**
+     * `Switch.Label`. Without it only the track renders — name it with `aria-label` or `aria-labelledby`.
+     */
     children?: React.ReactNode;
-    /** The native `role="switch"` input. */
     ref?: React.Ref<HTMLInputElement>;
 };
-declare function SwitchRoot({ id, checked: checkedProp, defaultChecked, onCheckedChange, loading, invalid, hint, error, size: sizeProp, disabled: disabledProp, readOnly, className, "aria-describedby": ariaDescribedBy, children, ref, ...inputRest }: SwitchRootProps): import("react/jsx-runtime").JSX.Element;
+declare function SwitchRoot({ id, checked: checkedProp, defaultChecked, onCheckedChange, loading, invalid, hint, error, size: sizeProp, optional, labels: labelsProp, disabled: disabledProp, readOnly, className, "aria-describedby": ariaDescribedBy, children, ref, ...inputRest }: SwitchRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace SwitchRoot {
     var displayName: string;
 }

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

@@ -1,32 +1,56 @@
 import * as React from "react";
 import { type ControlSize, type PaletteColor } from "../../internal/states";
+import { type AsyncHandler } from "../../internal/usePendingChanges";
 export type TabsLabels = {
     /** Name of the close button of a removable tab; `{label}` is the tab's title. */
     remove: string;
 };
+export declare const TABS_LABELS: TabsLabels;
 type TabsOrientation = "horizontal" | "vertical";
 export type TabsRootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue"> & {
+    /**
+     * Active tab (controlled).
+     */
     value?: string;
+    /**
+     * Initial active tab (uncontrolled). With `""` no tab is selected.
+     */
     defaultValue?: string;
+    /**
+     * Called with the new active value.
+     */
     onValueChange?: (value: string) => void;
-    /** Default `horizontal`. A vertical list stacks above the panel in containers narrower than 600px. */
+    /**
+     * List direction and arrow keys. Vertical: a column of sections beside the panel, which becomes a horizontal strip in a container below 600px.
+     */
     orientation?: TabsOrientation;
+    /**
+     * Control tier: text, icon, spacing, folder radius and the gap between the strip and the panel; a tab is at least the control height. Without it the tier of the host.
+     */
     size?: ControlSize;
-    /** Text and icon colour of the active tab. Default `neutral`: primary text, accent icon. */
+    /**
+     * Colour of the active tab: `neutral` is primary text with an accent icon, `accent` puts text and icon in accent.
+     */
     tone?: "neutral" | "accent";
     /**
-     * Horizontal tabs fill the list and tend to equal widths, never narrower than their content.
-     * Default `true`; `false` sizes each tab to its content.
+     * Horizontal tabs fill the list and tend to equal widths within `minItemWidth` … `maxItemWidth`; `false` sizes each tab to its content within the same bounds.
      */
     fullWidth?: boolean;
-    /** Narrowest a horizontal tab with a label gets (px or a CSS length); never below its content. */
+    /**
+     * Narrowest a horizontal tab with a label gets, px or a CSS length; a tab is also never narrower than its content (up to `maxItemWidth`).
+     */
     minItemWidth?: number | string;
-    /** Widest a horizontal tab gets (px or a CSS length); a longer label ends with an ellipsis. */
+    /**
+     * Widest a horizontal tab gets, px or a CSS length (`"none"` lifts the cap); a longer label ends with an ellipsis.
+     */
     maxItemWidth?: number | string;
+    /**
+     * Built-in strings, see Labels.
+     */
     labels?: Partial<TabsLabels>;
     ref?: React.Ref<HTMLDivElement>;
 };
-declare function TabsRoot({ value, defaultValue, onValueChange, orientation, size, tone, fullWidth, minItemWidth, maxItemWidth, labels, children, className, style, ...rest }: TabsRootProps): import("react/jsx-runtime").JSX.Element;
+declare function TabsRoot({ value, defaultValue, onValueChange, orientation, size: sizeProp, tone, fullWidth, minItemWidth, maxItemWidth, labels, children, className, style, ...rest }: TabsRootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace TabsRoot {
     var displayName: string;
 }
@@ -38,18 +62,20 @@ declare namespace TabsList {
     var displayName: string;
 }
 export type TabsItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "value" | "type" | "role" | "onClick"> & {
+    /**
+     * Value that selects this tab and its panel.
+     */
     value: string;
+    /**
+     * Disables the tab; clicks and arrow keys skip it.
+     */
     disabled?: boolean;
     /**
-     * Makes the tab closable: a close button, `Delete` / `Backspace` on the focused tab and a middle
-     * click. Closing the active tab selects its neighbour; remove the item in this callback. Return a
-     * promise to confirm first (unsaved changes): while pending the close button shows loading and
-     * the tab stays selected; resolved — the neighbour takes over; rejected — nothing changes.
+     * Makes the tab closable (close button, `Delete` / `Backspace`, middle click); remove the item from your list here. Return a promise to confirm first: rejected, the tab stays.
      */
-    onRemove?: () => void | Promise<void>;
+    onRemove?: AsyncHandler;
     /**
-     * Plain text, or parts: `Tabs.Icon`, `Tabs.Label`, `Tabs.Count`, `Tabs.Description`.
-     * A `Tabs.Description` makes the item two-line and becomes its accessible description.
+     * Plain text, or `Tabs.Icon` / `Tabs.Label` / `Tabs.Count` / `Tabs.Description`. A description makes the tab two-line.
      */
     children: React.ReactNode;
     ref?: React.Ref<HTMLButtonElement>;
@@ -59,6 +85,9 @@ declare namespace TabsItem {
     var displayName: string;
 }
 export type TabsIconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    /**
+     * The icon, e.g. `<Icon name="field.calendar" />`.
+     */
     children: React.ReactNode;
     ref?: React.Ref<HTMLSpanElement>;
 };
@@ -67,20 +96,29 @@ declare namespace TabsIcon {
     var displayName: string;
 }
 export type TabsLabelProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    /**
+     * Title text.
+     */
     children: React.ReactNode;
     ref?: React.Ref<HTMLSpanElement>;
 };
 /**
  * Tab title; truncates with an ellipsis in a narrow tab. Text labels reserve the width of the
- * medium weight, so the row does not shift when a tab becomes active.
+ * medium weight, so the row does not shift when a tab becomes active. In a list collapsed to
+ * icons the visible title leaves the row and a VisuallyHidden copy keeps naming the tab.
  */
 declare function TabsLabel({ children, className, ...rest }: TabsLabelProps): import("react/jsx-runtime").JSX.Element;
 declare namespace TabsLabel {
     var displayName: string;
 }
 export type TabsCountProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children" | "color"> & {
-    /** Badge hue. Default `gray`. */
+    /**
+     * Badge hue.
+     */
     color?: PaletteColor;
+    /**
+     * The number.
+     */
     children: React.ReactNode;
     ref?: React.Ref<HTMLSpanElement>;
 };
@@ -90,7 +128,9 @@ declare namespace TabsCount {
     var displayName: string;
 }
 export type TabsDescriptionProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
-    /** Muted second line; wrap a key value in `<strong>` to emphasize it. */
+    /**
+     * Second-line text; wrap a key value in `<strong>`.
+     */
     children: React.ReactNode;
     ref?: React.Ref<HTMLSpanElement>;
 };
@@ -107,10 +147,13 @@ declare namespace TabsSeparator {
     var displayName: string;
 }
 export type TabsPanelProps = React.HTMLAttributes<HTMLDivElement> & {
+    /**
+     * Tab value this panel belongs to.
+     */
     value: string;
     ref?: React.Ref<HTMLDivElement>;
 };
-declare function TabsPanel({ value, children, className, ...rest }: TabsPanelProps): import("react/jsx-runtime").JSX.Element | null;
+declare function TabsPanel({ value, ...rest }: TabsPanelProps): import("react/jsx-runtime").JSX.Element | null;
 declare namespace TabsPanel {
     var displayName: string;
 }