@tensor_1/react 2.30.0 → 2.32.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as react from 'react';
-import { RefObject, AnchorHTMLAttributes, ReactNode, ButtonHTMLAttributes, HTMLAttributes, InputHTMLAttributes, AriaAttributes, Ref, TextareaHTMLAttributes, SelectHTMLAttributes, MouseEvent, DetailsHTMLAttributes, TdHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, LiHTMLAttributes, ReactElement } from 'react';
-import { P as Placement } from './overlay-position-Cjv5E7mn.cjs';
-export { A as Align, a as PositionOptions, b as PositionResult, R as Rect, S as Side, c as Size, d as computePosition } from './overlay-position-Cjv5E7mn.cjs';
+import { RefObject, AnchorHTMLAttributes, ReactNode, ButtonHTMLAttributes, HTMLAttributes, SelectHTMLAttributes, InputHTMLAttributes, AriaAttributes, Ref, TextareaHTMLAttributes, MouseEvent, DetailsHTMLAttributes, LiHTMLAttributes, TdHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, ReactElement } from 'react';
+import { P as Placement } from './overlay-position-2Afke51l.cjs';
+export { A as Align, a as PositionOptions, b as PositionResult, R as Rect, S as Side, c as Size, d as computePosition } from './overlay-position-2Afke51l.cjs';
 
 declare function cx(...args: (string | false | null | undefined | 0)[]): string;
 
@@ -80,8 +80,15 @@ interface VirtualWindow {
  * [start, end) plus `overscan` rows on each side; padTop/padBottom are spacer
  * heights (px) so the scrollbar stays correct. Below `threshold` rows, callers
  * should skip virtualization (render all) — see shouldVirtualize.
+ *
+ * `scrollTop` is clamped to what a list of `count` rows can scroll to. A scroll position left
+ * over from a longer list (5,000 rows filtered down to 150 while scrolled far down) then gives
+ * the last rows and a spacer no taller than the list, in the same pass — not an empty window
+ * under a spacer taller than everything, which the browser only corrects scroll by scroll
+ * (HAR-1616).
  */
 declare function virtualWindow(scrollTop: number, viewportH: number, rowH: number, count: number, overscan?: number): VirtualWindow;
+/** `count > threshold`: a list of exactly `threshold` rows is still rendered whole. */
 declare function shouldVirtualize(count: number, threshold?: number): boolean;
 /** Clamp a dragged column width to a sane minimum (and optional maximum). */
 declare function clampWidth(width: number, min?: number, max?: number): number;
@@ -152,8 +159,21 @@ interface UseVirtualRowsOptions {
     rowHeight: number;
     /** Rows rendered beyond each viewport edge. Default: 6. */
     overscan?: number;
-    /** Render all rows at or below this count. Default: 100. */
+    /**
+     * Render all rows at or below this count: rows are windowed only when
+     * `rows.length > threshold` (so exactly `threshold` rows are still rendered whole).
+     * Default: 100.
+     */
     threshold?: number;
+    /**
+     * Viewport height in pixels to assume until the scroll element has been measured, and
+     * whenever it measures 0 (first render, a hidden tab, a test without layout). With it, a
+     * 5,000-row table mounts with one window of rows; without it every row is rendered until
+     * the first measurement, as before (HAR-1616).
+     */
+    estimatedViewportHeight?: number;
+    /** `false` renders every row with no spacers, whatever the count. Default: `true`. */
+    enabled?: boolean;
 }
 interface UseVirtualRowsResult<T> {
     /** Attach to the scrolling TableWrap. */
@@ -168,8 +188,10 @@ interface UseVirtualRowsResult<T> {
 /**
  * Owns scroll/resize observation and exposes the small visible row window.
  * Consumers render padTop/padBottom spacer rows inside their existing tbody.
+ * When the row count shrinks under a large scroll position the window is clamped to the new
+ * count in the same render, so `padTop` never exceeds the list (HAR-1616).
  */
-declare function useVirtualRows<T>(rows: readonly T[], { rowHeight, overscan, threshold }: UseVirtualRowsOptions): UseVirtualRowsResult<T>;
+declare function useVirtualRows<T>(rows: readonly T[], { rowHeight, overscan, threshold, estimatedViewportHeight, enabled }: UseVirtualRowsOptions): UseVirtualRowsResult<T>;
 
 interface UseAnchoredPositionOptions {
     /** Reposition while true, and (re)attach scroll/resize listeners. */
@@ -177,6 +199,25 @@ interface UseAnchoredPositionOptions {
     placement?: Placement;
     offset?: number;
     padding?: number;
+    /**
+     * Keep the element inside the viewport on the side it hangs off as well: when it fits neither
+     * above nor below (or left nor right) it slides over the anchor instead of leaving the
+     * viewport. Once the anchor itself has left the viewport the element follows it out; pair
+     * that with `onAnchorHidden` to close it. Default true.
+     */
+    shiftMainAxis?: boolean;
+    /**
+     * Cap the element's height to the viewport minus the padding on both edges, and let it scroll
+     * (`overflow-y: auto`, unless its own CSS already sets an overflow). A `max-height` from the
+     * element's own CSS still applies when it is smaller. Default false.
+     */
+    capHeight?: boolean;
+    /**
+     * Called when the anchor has scrolled completely out of view (outside the viewport or a
+     * clipping ancestor) while `open`. Close the overlay here; `Popover closeWhenAnchorHidden`
+     * is built on it.
+     */
+    onAnchorHidden?: () => void;
 }
 /**
  * Position a floating element (a native-popover overlay) against an anchor with
@@ -189,10 +230,14 @@ interface UseAnchoredPositionOptions {
  * `position: fixed` + left/top and follows scroll/resize from JS. While `open`, the side
  * chosen at open is kept until it no longer fits and the other side does, scrolls inside
  * the overlay itself are ignored, and a size change of either element re-places it.
+ * An element that fits on neither side is kept inside the viewport (it covers the anchor).
+ * While it is held there, or within `ANCHOR_BAND` of the limit, it is written as fixed
+ * coordinates even where anchor positioning exists: those cannot drift while the page scrolls,
+ * so it is inside on every frame, not one frame later (HAR-1613).
  * Returns a `reposition` fn for callers that want to nudge it manually (e.g. right when a
  * native popover's `toggle` fires).
  */
-declare function useAnchoredPosition(anchor: RefObject<HTMLElement | null> | HTMLElement | null | undefined, floatingRef: RefObject<HTMLElement | null>, { open, placement, offset, padding }: UseAnchoredPositionOptions): () => void;
+declare function useAnchoredPosition(anchor: RefObject<HTMLElement | null> | HTMLElement | null | undefined, floatingRef: RefObject<HTMLElement | null>, { open, placement, offset, padding, shiftMainAxis, capHeight, onAnchorHidden }: UseAnchoredPositionOptions): () => void;
 
 /**
  * What a `renderLink` callback receives (HAR-1348). Spread it onto your router's link
@@ -312,9 +357,149 @@ declare function startOfMonth(value: string): string;
 /** A weekday in `Date.getUTCDay()` numbering: 0 = Sunday … 6 = Saturday. */
 type CalendarWeekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 declare function buildMonthGrid(month: string, weekStartsOn?: CalendarWeekday): CalendarDay[];
+/**
+ * A shared `Intl.DateTimeFormat` for `locale` and `options`. Formatters are expensive to
+ * build, so one instance is kept per locale and options shape (key order does not matter);
+ * the cache holds up to 64 shapes and drops the oldest past that.
+ */
+declare function cachedDateTimeFormat(locale: string | readonly string[] | undefined, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+/** The calendar date (`YYYY-MM-DD`) of an instant in `timeZone`. */
 declare function zonedDateKey(instant: string | Date, timeZone: string): string;
+/**
+ * The 24-hour wall-clock time (`HH:MM`) of an instant in `timeZone`. It reads the same
+ * cached formatter as the zone math, so it adds no `Intl.DateTimeFormat` instance.
+ */
+declare function zonedTimeOfDay(instant: string | number | Date, timeZone: string): string;
+interface ZonedDayBounds {
+    /** The first instant of the day in the zone (local 00:00, or the first existing time after a gap). */
+    start: Date;
+    /** The first instant of the next day: `end` of D equals `start` of D + 1. */
+    end: Date;
+}
+/**
+ * The half-open interval `[start, end)` of a calendar day in `timeZone`. DST days are 23 or
+ * 25 hours long; a day whose midnight does not exist starts at its first existing instant.
+ */
+declare function zonedDayBounds(dateKey: string, timeZone: string): ZonedDayBounds;
+interface ZonedHourSlot {
+    /** The real instant the local hour starts. */
+    instant: Date;
+    /** The local hour, two digits (`'00'` … `'23'`). */
+    label: string;
+    /**
+     * The UTC offset (`'+02:00'`) when this local hour occurs twice in the day (clocks went
+     * back), set on both occurrences; otherwise `null`.
+     */
+    offsetLabel: string | null;
+}
+/**
+ * One entry per real hour start in the day `[start, end)` in `timeZone`: 24 on most days,
+ * 23 when clocks go forward (no slot for the skipped hour) and 25 when they go back (the
+ * repeated hour twice, each with an `offsetLabel`).
+ */
+declare function zonedHourSlots(dateKey: string, timeZone: string): ZonedHourSlot[];
+interface ZonedDayShift {
+    instant: Date;
+    /** `'gap_forward'` when the target wall-clock time did not exist and moved forward past the gap. */
+    adjusted: 'gap_forward' | null;
+}
+/**
+ * Moves an instant by `days` calendar days in `timeZone`, keeping its wall-clock time
+ * ("+1 day" is the same local time on the next day, whether that day has 23, 24 or 25
+ * hours). A wall time that occurs twice keeps the source's offset when it can (else the
+ * earlier one). A wall time that does not exist moves forward by the gap, once, and the
+ * result says so (`adjusted: 'gap_forward'`).
+ */
+declare function addZonedDays(instant: string | Date, days: number, timeZone: string): ZonedDayShift;
+/**
+ * Calendar days `[start, end)` as date keys: `end` is the first day NOT covered.
+ * Produced by `zonedDaySpan`, read by `enumerateDateKeys`.
+ */
+interface ZonedDaySpan {
+    start: string;
+    end: string;
+}
+/**
+ * The calendar days an instant interval `[start, end)` touches in `timeZone`, end-exclusive:
+ * an entry ending exactly at local 00:00 occupies only the day before. Throws a `RangeError`
+ * when `end` is not after `start`; it never swaps the ends.
+ */
+declare function zonedDaySpan(start: string | Date, end: string | Date, timeZone: string): ZonedDaySpan;
+/**
+ * The date keys of a `ZonedDaySpan` (`[start, end)`), at most `limit` of them (default
+ * 370; `Infinity` for no limit). `truncated` is true when the span has more days than were
+ * returned, so a long span is never cut silently. Throws a `RangeError` on an inverted span.
+ */
+declare function enumerateDateKeys(span: ZonedDaySpan, options?: {
+    limit?: number;
+}): {
+    dates: string[];
+    truncated: boolean;
+};
+/**
+ * Inclusive date keys of an instant interval, with inverted ends swapped.
+ * @deprecated Use `zonedDaySpan`, which is end-exclusive (an entry ending at local 00:00
+ * does not paint the next day) and throws on an inverted interval instead of swapping.
+ * The behaviour here is unchanged in 2.x; changing it follows the contract-change process (E13).
+ */
 declare function zonedDateSpan(start: string, end: string, timeZone: string): ZonedDateSpan;
+/**
+ * Date keys of an inclusive span, stopping silently after `limit` (370).
+ * @deprecated Use `enumerateDateKeys`, which reads an end-exclusive `ZonedDaySpan` and
+ * reports `truncated` instead of stopping silently. The behaviour here is unchanged in 2.x (E13).
+ */
 declare function enumerateDateSpan(span: ZonedDateSpan, limit?: number): string[];
+interface LaneInterval {
+    id: string;
+    /** Half-open `[start, end)`: ISO string, epoch ms or Date. */
+    start: string | number | Date;
+    end: string | number | Date;
+}
+interface LanePlacement {
+    /** 0-based lane, or `null` when the interval did not fit in `maxLanes`. */
+    lane: number | null;
+    /** Index into `PackedLanes.clusters`. */
+    cluster: number;
+}
+interface LaneCluster {
+    /** Ids of one run of transitively overlapping intervals, by start, then end, then id. */
+    ids: string[];
+    /** Lanes the cluster uses (≤ `maxLanes`); a renderer divides the width by this. */
+    laneCount: number;
+    /** Intervals of the cluster that got no lane. */
+    overflow: number;
+}
+interface PackedLanes {
+    lanes: Record<string, LanePlacement>;
+    clusters: LaneCluster[];
+    /** Intervals that got no lane, over all clusters. */
+    overflow: number;
+}
+interface PackLanesOptions {
+    /**
+     * `'start'` (default): greedy first-fit by start, then end, then id, so the result does
+     * not depend on input order. `'given'`: first-fit in input order, so the consumer's
+     * ranking decides which intervals get a lane when there are not enough.
+     */
+    order?: 'start' | 'given';
+}
+/**
+ * Assigns half-open intervals to at most `maxLanes` lanes, first-fit. Two intervals that
+ * overlap never share a lane; two that only touch (`a.end === b.start`) may. Intervals
+ * that do not fit get `lane: null` and count towards their cluster's `overflow`. A
+ * zero-length interval occupies its start instant. Throws on `end < start` (it never
+ * swaps) and on a duplicate id.
+ */
+declare function packLanes(intervals: readonly LaneInterval[], maxLanes: number, options?: PackLanesOptions): PackedLanes;
+/**
+ * Sorts a copy of `items` with `compare` (stable) and cuts it after `n`. `hidden` is the
+ * number of items not shown, so it is a true total only when `items` is complete; a
+ * consumer that knows a larger total shows that instead.
+ */
+declare function rankOverflow<T>(items: readonly T[], compare: (a: T, b: T) => number, n: number): {
+    visible: T[];
+    hidden: number;
+};
 declare function selectRangeDate(current: DateRangeValue, date: string): DateRangeValue;
 declare function isDateInRange(date: string, value: DateRangeValue): boolean;
 declare function isDateUnavailable(date: string, options: {
@@ -323,9 +508,90 @@ declare function isDateUnavailable(date: string, options: {
     isDisabled?: (date: string) => boolean;
 }): boolean;
 
+/** Which lane group a span is drawn in: windows sit above multi-day items, and neither takes a chip slot. */
+type MonthSpanGroup = 'window' | 'item';
+interface MonthSpanInput {
+    id: string;
+    /** Half-open `[start, end)` instants (ISO 8601, epoch ms or Date). */
+    start: string | number | Date;
+    end: string | number | Date;
+    /** Defaults to `'item'`. */
+    group?: MonthSpanGroup;
+}
+interface PlacedMonthSpan {
+    id: string;
+    group: MonthSpanGroup;
+    /** 0-based week row of the grid `days` the layout was computed for. */
+    weekRow: number;
+    /** 0-based lane inside its group. */
+    lane: number;
+    /** First and last column (0–6, inclusive) the span covers in this row. */
+    startCol: number;
+    endCol: number;
+    /** The span started in an earlier row (or before the grid). */
+    continuesBefore: boolean;
+    /** The span goes on in a later row (or past the grid). */
+    continuesAfter: boolean;
+}
+interface MonthSpanLayout {
+    /** One entry per span per week row it got a lane in. Render exactly these; never re-pack. */
+    placed: PlacedMonthSpan[];
+    /** Per week row, the ids that got no lane, in input order (windows first). An id may name a window and an item. */
+    hiddenByRow: Record<number, string[]>;
+    /** Per week row with a hidden span, the first day (`YYYY-MM-DD`) a hidden span covers. */
+    firstHiddenDayByRow: Record<number, string>;
+}
+interface LayoutMonthSpansOptions {
+    /** The display zone that decides which days a span covers. */
+    timeZone: string;
+    /** When set, `days[0]` must fall on this weekday (a guard against a grid built for another week start). */
+    weekStartsOn?: CalendarWeekday;
+    /** Lanes per group (default 2). A number applies to both groups. */
+    laneCap?: number | Partial<Record<MonthSpanGroup, number>>;
+}
+/**
+ * The calendar days an item covers in `timeZone`, end-exclusive (`end` is the first day not
+ * covered): a 22:00–00:00 item covers only its start day, a 23:00 → 02:00 item two days. A
+ * zero-length item covers the day of its start. Throws a `RangeError` when `end` is before
+ * `start`; it never swaps them.
+ */
+declare function itemDaySpan(start: string | number | Date, end: string | number | Date, timeZone: string): ZonedDaySpan;
+/**
+ * The date keys a `SchedulingCalendar` grid shows, in order: six week rows for `'month'`
+ * (from the week holding the 1st), one for `'week'` (the week holding `anchorDate`). Pass the
+ * result to `layoutMonthSpans` so the layout and the rendered grid agree.
+ */
+declare function schedulingGridDays(anchorDate: string, view: 'month' | 'week', weekStartsOn?: CalendarWeekday): string[];
+/**
+ * Places multi-day spans as one continuous bar per week row. Spans are taken **in the order
+ * given** (the consumer's salience order): in each row and group, the first spans to ask get
+ * the lanes, the rest are listed in `hiddenByRow`. Windows and items pack in separate groups,
+ * each capped by `laneCap`. Day membership is the end-exclusive zoned span in `timeZone`
+ * (never a UTC date). `days` are the grid's date keys, a whole number of weeks.
+ */
+declare function layoutMonthSpans(spans: readonly MonthSpanInput[], days: readonly string[], options: LayoutMonthSpansOptions): MonthSpanLayout;
+
 type SchedulingCalendarView = 'month' | 'week' | 'agenda';
+/**
+ * @deprecated Use `band`, `status` and `markers` on the entry: they carry no product
+ * vocabulary and the consumer supplies every word. The values keep working in 2.x.
+ */
 type SchedulingEntryState = 'scheduled' | 'conflicted' | 'in-progress' | 'blackout-violation';
+/** @deprecated Use `pattern` and `kindLabel` on the overlay. The values keep working in 2.x. */
 type SchedulingOverlayKind = 'maintenance' | 'blackout';
+/**
+ * The one dimension that takes a hue. `none` and `low` are untinted, `medium` gets a
+ * heavier edge, and only `high` is filled. The consumer decides what a band means.
+ */
+type SchedulingBand = 'none' | 'low' | 'medium' | 'high';
+/**
+ * The state channel, drawn without hue: `tentative` is dashed, `committed` is the plain
+ * item, `live` carries a leading dot, `done` is dimmed and `dead` is struck through.
+ */
+type SchedulingStatus = 'tentative' | 'committed' | 'live' | 'done' | 'dead';
+type SchedulingMarkerEmphasis = 'refused' | 'warning' | 'neutral';
+/** How a window is hatched. Windows are neutral: the pattern and the visible label tell them apart. */
+type SchedulingOverlayPattern = 'diagonal' | 'cross' | 'dotted' | 'solid';
 /**
  * Which date text a `formatDate` call is for (TENSOR B1/C9, HAR-1347):
  * `day` names one day (each day cell's accessible name, the week-range title);
@@ -333,20 +599,66 @@ type SchedulingOverlayKind = 'maintenance' | 'blackout';
  * `month` is the month-view title (the date is the first of the month).
  */
 type SchedulingDatePart = 'day' | 'weekday' | 'month';
+/** A shape or icon with text. The text is always in the accessible name; a marker never relies on colour. */
+interface SchedulingMarker {
+    id: string;
+    /** An icon from `@tensor_1/react/icons`. Without one the marker draws a shape for its `emphasis`. */
+    icon?: ReactNode;
+    label: string;
+    emphasis?: SchedulingMarkerEmphasis;
+}
 interface SchedulingCalendarEntry {
     id: string;
     title: string;
     start: string;
     end: string;
+    /** @deprecated Use `band`, `status` and `markers`. */
     state?: SchedulingEntryState;
     meta?: string;
+    band?: SchedulingBand;
+    status?: SchedulingStatus;
+    markers?: SchedulingMarker[];
+    /** The complete accessible name, built by the consumer from its own words. Replaces `labels.entry`. */
+    accessibleName?: string;
 }
 interface SchedulingCalendarOverlay {
     id: string;
+    /** The window's name, shown as text. */
     label: string;
     start: string;
     end: string;
-    kind: SchedulingOverlayKind;
+    /** @deprecated Use `pattern` and `kindLabel`. */
+    kind?: SchedulingOverlayKind;
+    /** Defaults to `'solid'`. */
+    pattern?: SchedulingOverlayPattern;
+    /** What kind of window this is, in the consumer's words. Shown before the name. */
+    kindLabel?: string;
+    /** What the window applies to. Shown after the name. */
+    scopeLabel?: string;
+    /** The window applies to everything. A window that is not global never gets the global treatment. */
+    global?: boolean;
+    /** The complete accessible name. Replaces `labels.overlay`. */
+    accessibleName?: string;
+}
+/** What the consumer knows about one day (`YYYY-MM-DD`). The calendar shows these numbers and never derives them. */
+interface SchedulingCalendarDay {
+    /** Every item on the day, shown in the cell even when no chip fits. */
+    count: number;
+    /** The "+N" of the cell. 0 shows none. */
+    overflowCount: number;
+    /** The accessible text of the count, e.g. "7 items, 2 need review". */
+    label?: string;
+    markers?: SchedulingMarker[];
+}
+interface SchedulingLegendItem {
+    id: string;
+    label: string;
+    swatch: {
+        band?: SchedulingBand;
+        status?: SchedulingStatus;
+        pattern?: SchedulingOverlayPattern;
+        icon?: ReactNode;
+    };
 }
 /**
  * Every word the calendar renders (TENSOR RX-125, UIX-12). `{timeZone}`, `{view}`,
@@ -354,8 +666,15 @@ interface SchedulingCalendarOverlay {
  */
 interface SchedulingCalendarLabels {
     region: string;
+    /** @deprecated Use `previousMonth` and `previousWeek`. Still used when those are not set. */
     previous: string;
+    /** @deprecated Use `nextMonth` and `nextWeek`. Still used when those are not set. */
     next: string;
+    previousMonth?: string;
+    nextMonth?: string;
+    /** Also names the agenda's step, which moves by a week. */
+    previousWeek?: string;
+    nextWeek?: string;
     viewGroup: string;
     viewMonth: string;
     viewWeek: string;
@@ -365,7 +684,10 @@ interface SchedulingCalendarLabels {
     agenda: string;
     agendaEmpty: string;
     grid: string;
+    /** An entry's accessible name unless it sets `accessibleName`. Its marker labels are appended. */
     entry: string;
+    /** A window's accessible name unless it sets `accessibleName`. `{title}` is its kind, name and scope. */
+    overlay?: string;
     legend: string;
     /** The "+N more" toggle on a day with more entries than `maxEntriesPerDay`. `{count}` placeholder. */
     moreEntries: string;
@@ -373,19 +695,36 @@ interface SchedulingCalendarLabels {
     moreEntriesLabel: string;
     /** The toggle once the day is expanded in place. */
     fewerEntries: string;
+    /** The "+N" at the end of a week row whose spans did not all get a lane. `{count}` placeholder. */
+    moreSpans?: string;
+    /** Accessible name of that control. `{count}` and `{date}` (the first day with a hidden span). */
+    moreSpansLabel?: string;
+    /** The accessible text of a day's count when `days[date].label` is not given. `{count}` placeholder. */
+    dayCount?: string;
     states: Record<SchedulingEntryState, string>;
+    /** The words for `status`, used in the default accessible name and the agenda. */
+    statuses?: Partial<Record<SchedulingStatus, string>>;
 }
 declare const DEFAULT_SCHEDULING_CALENDAR_LABELS: SchedulingCalendarLabels;
 interface SchedulingCalendarProps {
+    /**
+     * The entries. Without `dayEntries` the calendar places each on its day in the order
+     * given; with `dayEntries` only the entries that cover more than one day are read from
+     * here (they are drawn as spans).
+     */
     entries: SchedulingCalendarEntry[];
     anchorDate: string;
     timeZone: string;
     view?: SchedulingCalendarView;
     onViewChange?: (view: SchedulingCalendarView) => void;
     onAnchorDateChange?: (date: string) => void;
+    /** Called by a click or Enter on a chip, a span or an agenda row. */
     onSelectEntry?: (entry: SchedulingCalendarEntry) => void;
     overlays?: SchedulingCalendarOverlay[];
+    /** Called by a click or Enter on a window span. */
+    onSelectOverlay?: (overlay: SchedulingCalendarOverlay) => void;
     filter?: (entry: SchedulingCalendarEntry) => boolean;
+    /** Replaces a chip's content. The default is the start time in `timeZone` (24 h) and the title. */
     renderEntry?: (entry: SchedulingCalendarEntry) => ReactNode;
     locale?: string;
     /** First column of the month and week grids: 0 = Sunday … 6 = Saturday. Defaults to 1 (Monday). */
@@ -396,20 +735,23 @@ interface SchedulingCalendarProps {
      */
     formatDate?: (date: string, part: SchedulingDatePart) => string;
     /**
-     * Formats an entry's start or end instant (ISO 8601) for the agenda and the entry names.
-     * The component does not shift it: render it in `timeZone` yourself. Defaults to `Intl`
-     * medium date + short time in `timeZone`.
+     * Formats a start or end instant (ISO 8601) for the agenda and the accessible names.
+     * The component does not shift it: render it in `timeZone` yourself. Defaults to the
+     * `day` date text followed by the 24-hour time in `timeZone`.
      */
     formatInstant?: (instant: string) => string;
     /**
-     * Show at most this many entries in a month or week day; the rest collapse behind a
-     * "+N more" toggle. Unset shows every entry.
+     * How many chips a day shows. Without `dayEntries` the rest collapse behind "+N more";
+     * with `dayEntries` it only sizes the cell (the consumer already cut the list, and a longer
+     * list makes the cells taller, never clipped). Unset shows every entry where the cells
+     * grow, and sizes a fixed cell for three chips.
      */
     maxEntriesPerDay?: number;
     /**
-     * Called by the "+N more" toggle with the day and every entry on it. When set, the
-     * consumer shows them (a popover, a drawer, the day view) and the day stays collapsed;
-     * otherwise the day expands in place.
+     * Called by a day's "+N more" and by a week row's "+N" with the day (and, without
+     * `dayEntries`, every entry on it). When set, the consumer shows them (a popover, a
+     * drawer, the day view) and the day stays collapsed. Required with `days` or `dayEntries`:
+     * a controlled day never expands in place.
      */
     onShowMore?: (date: string, entries: SchedulingCalendarEntry[]) => void;
     /**
@@ -419,6 +761,42 @@ interface SchedulingCalendarProps {
      * to the number). Return null for no badge.
      */
     renderDayBadge?: (date: string, entries: SchedulingCalendarEntry[]) => ReactNode;
+    /**
+     * Consumer-owned numbers per day (`YYYY-MM-DD`). When set, each listed day shows its
+     * `count` and markers even with no chip, and its "+N" is `overflowCount`, never a number
+     * derived from the entries given. Without `dayEntries` the chips are still this day's
+     * `entries`, cut to `maxEntriesPerDay`; the day never expands in place.
+     */
+    days?: Record<string, SchedulingCalendarDay>;
+    /**
+     * The single-day chips of each day, already ranked and cut by the consumer. When set, the
+     * calendar renders exactly these in the order given: it does not place, rank, cut or count.
+     */
+    dayEntries?: Record<string, SchedulingCalendarEntry[]>;
+    /**
+     * The result of `layoutMonthSpans` for this grid. When set, the calendar draws exactly
+     * these spans and never packs lanes itself. Compute it with `schedulingGridDays`.
+     */
+    spanLayout?: MonthSpanLayout;
+    /**
+     * Lanes kept for windows above the chips. Windows never take a chip slot. Default 2 where
+     * the cells have a fixed height; where they grow with their content every window gets a lane.
+     */
+    windowLaneCap?: number;
+    /** Lanes kept for entries that cover more than one day. Default as for `windowLaneCap`. */
+    spanLaneCap?: number;
+    /** When set, the legend is exactly these items (an empty list draws no legend). Unset keeps the built-in state legend. */
+    legend?: SchedulingLegendItem[];
+    /** A line under the legend, e.g. the display zone. */
+    legendCaption?: ReactNode;
+    /** `false` hides the previous/next buttons, the title and the view switch (the page has its own toolbar). */
+    showHeader?: boolean;
+    /** Shown above the grid, e.g. "Showing the first 2,000 items". */
+    notice?: ReactNode;
+    /** Shown inside the grid, below the day cells, when there is nothing to show. */
+    emptyNote?: ReactNode;
+    /** Called by a click or Enter on a day number. */
+    onSelectDate?: (date: string) => void;
     loading?: boolean;
     error?: string;
     onRetry?: () => void;
@@ -426,7 +804,7 @@ interface SchedulingCalendarProps {
     labels?: Partial<SchedulingCalendarLabels>;
 }
 /** Month/week/agenda calendar for UTC ranges rendered in an explicit IANA time zone. */
-declare function SchedulingCalendar({ entries, anchorDate, timeZone, view: controlledView, onViewChange, onAnchorDateChange, onSelectEntry, overlays, filter, renderEntry, locale, weekStartsOn, formatDate, formatInstant: formatInstantProp, maxEntriesPerDay, onShowMore, renderDayBadge, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
+declare function SchedulingCalendar({ entries, anchorDate, timeZone, view: controlledView, onViewChange, onAnchorDateChange, onSelectEntry, overlays, onSelectOverlay, filter, renderEntry, locale, weekStartsOn, formatDate, formatInstant: formatInstantProp, maxEntriesPerDay, onShowMore, renderDayBadge, days: dayInfo, dayEntries, spanLayout, windowLaneCap, spanLaneCap, legend, legendCaption, showHeader, notice, emptyNote, onSelectDate, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
 
 /**
  * Every word the picker renders or announces (TENSOR RX-125, UIX-13). `{start}` and
@@ -462,9 +840,15 @@ interface DateRangePickerProps {
     className?: string;
     /** Translatable words; English defaults in {@link DEFAULT_DATE_RANGE_PICKER_LABELS}. */
     labels?: Partial<DateRangePickerLabels>;
+    /**
+     * The ISO date (`YYYY-MM-DD`) that gets the today ring and `aria-current="date"`.
+     * Defaults to the viewer's local date; pass it when rendering on a server (whose
+     * clock and zone may differ from the viewer's), or `null` for no today marker.
+     */
+    today?: string | null;
 }
 /** Controlled, two-month range picker using the UIx calendar language. */
-declare function DateRangePicker({ value, onChange, visibleMonth: controlledMonth, onVisibleMonthChange, months, min, max, isDateDisabled, locale, label, invalid, invalidMessage, disabled, className, labels: labelOverrides, }: DateRangePickerProps): react.JSX.Element;
+declare function DateRangePicker({ value, onChange, visibleMonth: controlledMonth, onVisibleMonthChange, months, min, max, isDateDisabled, locale, label, invalid, invalidMessage, disabled, className, labels: labelOverrides, today, }: DateRangePickerProps): react.JSX.Element;
 
 /**
  * Pure model for `SchedulingTimeline` (HAR-1364; TENSOR C8): ticks on a time axis, where a
@@ -638,6 +1022,735 @@ interface SchedulingTimelineProps {
  */
 declare function SchedulingTimeline({ lanes, items, range, scale, timeZone, locale, overlays, markers, now, weekStartsOn, tickWidth, step: stepProp, formatTick, formatInstant: formatInstantProp, renderItem, onSelectItem, onMoveItem, loading, error, onRetry, labels: labelOverrides, className, }: SchedulingTimelineProps): react.JSX.Element;
 
+/**
+ * Two-way text diff for `TextDiff` (HAR-1368). Pure. Myers' O(ND) diff on lines or words,
+ * after trimming the common prefix and suffix. Past `maxEdits` the changed middle is shown as
+ * one replacement instead of searching further, so a rewrite never stalls the page.
+ */
+type TextDiffGranularity = 'line' | 'word';
+interface TextDiffOp {
+    type: 'equal' | 'insert' | 'delete';
+    /** Lines (granularity `line`) or word, space and punctuation tokens (`word`). */
+    tokens: string[];
+}
+interface TextDiffOptions {
+    granularity?: TextDiffGranularity;
+    /** More tokens than this on either side gives `status: 'too-large'`. Default 20 000. */
+    maxTokens?: number;
+    /** Edit budget for the search; beyond it the middle becomes one replacement. Default 2 000. */
+    maxEdits?: number;
+}
+interface TextDiffResult {
+    status: 'ok' | 'too-large';
+    granularity: TextDiffGranularity;
+    ops: TextDiffOp[];
+    /** Lines, or words (not spaces or punctuation), added and removed. */
+    added: number;
+    removed: number;
+}
+/** Splits text into lines (without their `\r\n` / `\n`) or into word, space and punctuation tokens. */
+declare function tokenizeText(text: string, granularity: TextDiffGranularity): string[];
+/** Myers diff of two token lists. Tokens compare by string equality. */
+declare function diffTokens(a: readonly string[], b: readonly string[], maxEdits?: number): TextDiffOp[];
+/** Diffs two texts by line or by word, with added/removed counts. */
+declare function diffText(before: string, after: string, { granularity, maxTokens, maxEdits }?: TextDiffOptions): TextDiffResult;
+/** A run of text inside one line; `changed` marks the words that differ from the other side. */
+interface TextDiffSegment {
+    text: string;
+    changed: boolean;
+}
+interface TextDiffLine {
+    /** 1-based line number on its side. */
+    number: number;
+    /** Word-level marks when the line was paired with a similar counterpart; otherwise one changed segment. */
+    segments: TextDiffSegment[];
+}
+type TextDiffRow = {
+    kind: 'equal';
+    before: TextDiffLine;
+    after: TextDiffLine;
+} | {
+    kind: 'change';
+    before: TextDiffLine;
+    after: TextDiffLine;
+} | {
+    kind: 'delete';
+    before: TextDiffLine;
+} | {
+    kind: 'insert';
+    after: TextDiffLine;
+} | {
+    kind: 'fold';
+    count: number;
+    rows: TextDiffRow[];
+};
+/**
+ * Rows for a line diff: unchanged lines, removed/added lines, and changed lines paired side by
+ * side with word marks. With `context`, unchanged runs longer than needed fold into one row.
+ */
+declare function textDiffRows(result: TextDiffResult, { context }?: {
+    context?: number;
+}): TextDiffRow[];
+
+interface TextDiffLabels {
+    before: string;
+    after: string;
+    /** `{added}`, `{removed}`: lines or words, by granularity. */
+    summary: string;
+    noChanges: string;
+    /** Read before removed text. */
+    removed: string;
+    /** Read before added text. */
+    added: string;
+    /** Fold button. `{count}`. */
+    showUnchanged: string;
+    tooLarge: string;
+}
+declare const DEFAULT_TEXT_DIFF_LABELS: TextDiffLabels;
+interface TextDiffProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    before: string;
+    after: string;
+    /** Column heading for `before`, e.g. "Version 3". Defaults to `labels.before`. */
+    beforeLabel?: ReactNode;
+    afterLabel?: ReactNode;
+    /** `line` (default) pairs changed lines and marks the words inside; `word` diffs prose as one flow. */
+    granularity?: TextDiffGranularity;
+    /** `split` (default) puts the versions side by side, stacking on narrow containers; `unified` interleaves them. */
+    view?: 'split' | 'unified';
+    /** Line diffs: unchanged lines kept around each change; longer runs fold behind a button. Default: show all. */
+    context?: number;
+    /** Names the diff for assistive technology, e.g. "Changes to the article body". */
+    label?: string;
+    /** Hide the added/removed summary. */
+    hideSummary?: boolean;
+    /** Passed to the model (`maxTokens`, `maxEdits`); see `diffText`. */
+    maxTokens?: number;
+    maxEdits?: number;
+    labels?: Partial<TextDiffLabels>;
+}
+/**
+ * A two-way diff of two texts (HAR-1368; TENSOR C11 knowledge version diff): by line with word
+ * marks inside changed lines, or by word for prose; side by side or unified. Changes are `<del>` /
+ * `<ins>` with a −/+ sign and a spoken "Removed"/"Added", never colour alone. `DiffViewer` stays
+ * the three-way JSON configuration diff.
+ */
+declare function TextDiff({ before, after, beforeLabel, afterLabel, granularity, view, context, label, hideSummary, maxTokens, maxEdits, labels: labelOverrides, className, ...props }: TextDiffProps): react.JSX.Element;
+
+/**
+ * Typed column filters for `FilterEditor` (HAR-1365; TENSOR C6 `table-filter-editor.tsx`,
+ * MOTUS C-1 "+ filter"). The value is data the product serializes into its own query; the
+ * summary feeds a `Chip`. Pure, so a server can summarize a saved view too.
+ */
+interface FilterChoice {
+    value: string;
+    label: string;
+}
+type TextFilterOperator = 'contains' | 'not-contains' | 'is' | 'is-not' | 'starts-with';
+type NumberFilterOperator = 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte' | 'between';
+type FilterValue = {
+    kind: 'enum';
+    values: string[];
+} | {
+    kind: 'text';
+    operator: TextFilterOperator;
+    text: string;
+} | {
+    kind: 'number';
+    operator: NumberFilterOperator;
+    value?: number;
+    to?: number;
+} | {
+    kind: 'date-range';
+    from?: string;
+    to?: string;
+} | {
+    kind: 'boolean';
+    value?: boolean;
+} | {
+    kind: 'reference';
+    values: FilterChoice[];
+};
+type FilterValueKind = FilterValue['kind'];
+/**
+ * A named selection for an `enum` field (HAR-1505), e.g. "Open work" = new, open and pending.
+ * The id, label and values come from the product.
+ */
+interface FilterPreset {
+    id: string;
+    label: string;
+    /** The option values the preset selects. Compared as a set: order and repeats do not matter. */
+    values: readonly string[];
+}
+interface FilterField {
+    id: string;
+    /** Column name, also the start of the chip summary. */
+    label: string;
+    kind: FilterValueKind;
+    /** `enum`: the choices. */
+    options?: readonly FilterChoice[];
+    /** `reference`: finds records to pick; rejected promises show the error state. */
+    onSearch?: (query: string) => Promise<readonly FilterChoice[]>;
+    /** `text` / `number`: the operators offered, in order. Default: all of the kind. */
+    operators?: readonly (TextFilterOperator | NumberFilterOperator)[];
+    /** `number`: a unit shown after the value, e.g. "days". */
+    unit?: string;
+    /** `boolean`: words for true and false, e.g. Escalated / Not escalated. Default from labels. */
+    trueLabel?: string;
+    falseLabel?: string;
+    /**
+     * `enum`: named selections shown as toggle chips above the options. Activating one replaces
+     * the selection with its values; the one equal to the selection is pressed, and the chip
+     * summary names it.
+     */
+    presets?: readonly FilterPreset[];
+}
+interface FilterSummaryLabels {
+    operators: Record<TextFilterOperator | NumberFilterOperator, string>;
+    yes: string;
+    no: string;
+    /** `{from}`, `{to}`; also used for a number range. */
+    range: string;
+    /** Only a start date. `{from}`. */
+    from: string;
+    /** Only an end date. `{to}`. */
+    until: string;
+    /** More than `maxListed` values: `{first}`, `{count}`. */
+    more: string;
+    /** An `enum` value equal to a preset: `{label}` (the preset), `{field}`. Default `{label}`. */
+    preset?: string;
+}
+declare const DEFAULT_FILTER_SUMMARY_LABELS: FilterSummaryLabels;
+declare const TEXT_FILTER_OPERATORS: readonly TextFilterOperator[];
+declare const NUMBER_FILTER_OPERATORS: readonly NumberFilterOperator[];
+/** The empty value for a field kind (what Clear resets to). */
+declare function emptyFilterValue(kind: FilterValueKind): FilterValue;
+/** True when the value filters nothing (so the chip goes away). */
+declare function isFilterEmpty(value: FilterValue | undefined): boolean;
+/**
+ * The first of `field.presets` whose values equal the value's as a set, or undefined. Only an
+ * `enum` value can match a preset.
+ */
+declare function matchFilterPreset(field: FilterField, value: FilterValue | undefined): FilterPreset | undefined;
+interface SummarizeFilterOptions {
+    labels?: Partial<FilterSummaryLabels>;
+    /** Formats a `YYYY-MM-DD` date (a product format such as DD.MM.YYYY). Default: as given. */
+    formatDate?: (date: string) => string;
+    /** Formats a number. Default: `String`. */
+    formatNumber?: (value: number) => string;
+    /** List this many values before "+N". Default 2. */
+    maxListed?: number;
+}
+/**
+ * One line for the filter chip, e.g. "State: Open, Pending", "Priority ≥ 2", "Created:
+ * 01.10.2026 – 05.10.2026", "Escalated: Yes". An enum value equal to one of `field.presets`
+ * gives that preset's label (the `preset` label). Empty values give an empty string.
+ */
+declare function summarizeFilter(field: FilterField, value: FilterValue | undefined, options?: SummarizeFilterOptions): string;
+
+interface FilterEditorLabels {
+    apply: string;
+    clear: string;
+    operator: string;
+    value: string;
+    from: string;
+    to: string;
+    /** Between two numbers: "and". */
+    and: string;
+    any: string;
+    yes: string;
+    no: string;
+    search: string;
+    searching: string;
+    noMatches: string;
+    searchFailed: string;
+    retry: string;
+    selectAll: string;
+    selectNone: string;
+    /** `{count}` chosen. */
+    selected: string;
+    /** Remove one chosen record. `{label}`. */
+    remove: string;
+    /** Names the row of `field.presets` chips. Optional so existing label objects still type-check; default "Presets". */
+    presets?: string;
+    operators: Record<TextFilterOperator | NumberFilterOperator, string>;
+}
+declare const DEFAULT_FILTER_EDITOR_LABELS: FilterEditorLabels;
+interface FilterEditorProps {
+    field: FilterField;
+    /** Undefined means "not filtered yet". */
+    value: FilterValue | undefined;
+    onValueChange: (value: FilterValue) => void;
+    onApply: () => void;
+    onClear: () => void;
+    labels?: Partial<FilterEditorLabels>;
+    /** Show an option filter above an enum list once it has more options than this. Default 8. */
+    searchThreshold?: number;
+    /** Delay before a reference search runs, in ms. Default 250. */
+    searchDelay?: number;
+}
+/**
+ * Editor content for one typed column filter (HAR-1365; TENSOR C6, MOTUS C-1): an enum
+ * multi-select, text or number with a condition, a date range, yes/no, or records found by
+ * an async search. The product owns the popover trigger and the query; `summarizeFilter`
+ * turns the applied value into the chip text. `FilterPopover` stays for the one-string case.
+ * An enum field's `presets` (HAR-1505) render as toggle chips above its options. Words come
+ * from `labels`, or from `UixLabelsProvider`'s `filterEditor` entry.
+ */
+declare function FilterEditor({ field, value: valueProp, onValueChange, onApply, onClear, labels: labelOverrides, searchThreshold, searchDelay }: FilterEditorProps): react.JSX.Element;
+
+/**
+ * Select model (HAR-1572) — pure, DOM-free logic behind the UIx `Select` listbox:
+ * flattening options and groups, keyboard movement (APG select-only combobox), typeahead,
+ * filtering and the multi-select value helpers. Unit-tested in select-model.test.mjs.
+ */
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** A second, muted line under the label. */
+    description?: string;
+    /** Shown before the label, in the list and on the trigger. */
+    icon?: ReactNode;
+    /** Extra words that match a search or typeahead (never shown). */
+    keywords?: readonly string[];
+}
+interface SelectGroup {
+    label: string;
+    options: readonly SelectOption[];
+    /** Disables every option in the group. */
+    disabled?: boolean;
+}
+
+/** Chrome strings of `Select`; `{count}` is replaced where noted. */
+interface SelectLabels {
+    /** Accessible name of the filter field when the Select has no label of its own. */
+    search: string;
+    /** Placeholder of the filter field. */
+    searchPlaceholder: string;
+    loading: string;
+    /** No options at all. */
+    empty: string;
+    /** A filter matched nothing. */
+    noMatches: string;
+    /** Async `loadOptions` failed. */
+    error: string;
+    retry: string;
+    /** Multi-select: clears every value. */
+    clear: string;
+    /** Multi-select on a phone: closes the sheet. */
+    done: string;
+    /** Multi-select trigger, spoken after the "+N". `{count}` = how many are selected. */
+    selectedCount: string;
+    /** Announced after filtering. `{count}`. */
+    results: string;
+}
+interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
+    size?: 'sm' | 'md';
+    /** The options as data, instead of `<option>` / `<optgroup>` children. */
+    options?: readonly (SelectOption | SelectGroup)[];
+    /**
+     * Called with the new value: a string, or every selected value with `multiple`. `option` is the
+     * option that was chosen or toggled. `onChange(e)` still fires as on a native select.
+     */
+    onValueChange?: (value: string | string[], option?: SelectOption) => void;
+    /** Shown while nothing is selected. Also makes "nothing" the starting value (and `required` checks it). */
+    placeholder?: string;
+    /** Marks the control invalid (`aria-invalid`), e.g. from your own validation. */
+    invalid?: boolean;
+    /** Shows and submits the value, but does not open. */
+    readOnly?: boolean;
+    /** A filter field at the top of the list. `'auto'` adds it for more than 12 options. Default `false`. */
+    searchable?: boolean | 'auto';
+    /**
+     * Load the options when the list opens (and, when `searchable`, as the filter changes). The
+     * previous request's `signal` is aborted when a newer one starts or the list closes. Pass the
+     * selected option in `options` so its label shows before the first load.
+     */
+    loadOptions?: (query: string, signal: AbortSignal) => Promise<readonly (SelectOption | SelectGroup)[]>;
+    /** Draw an option's content (the check mark for the selected state is drawn for you). */
+    renderOption?: (option: SelectOption, state: {
+        selected: boolean;
+        active: boolean;
+    }) => ReactNode;
+    /** Draw the trigger's content for the selected option(s). */
+    renderValue?: (selected: readonly SelectOption[]) => ReactNode;
+    /** Preferred side of the list. Default `'bottom-start'`; it flips when there is no room. */
+    placement?: Placement;
+    labels?: Partial<SelectLabels>;
+}
+/**
+ * A select that draws its own list (HAR-1572): the WAI-ARIA APG select-only combobox — focus
+ * stays on the trigger, `aria-activedescendant` marks the active option — in a top-layer popover
+ * placed with `useAnchoredPosition`, or a bottom sheet on a phone. A visually hidden native
+ * `<select>` carries `name`, `required`, `form`, `multiple` and the value, so `<option>` children,
+ * `onChange(e)` with `e.target.value`, FormData, `form.reset()`, `ref` and react-hook-form keep
+ * working; `ref` points at that select.
+ */
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+
+interface RuleCondition {
+    id: string;
+    field: string;
+    operator: string;
+    value?: JsonValue;
+}
+interface RuleGroup {
+    id: string;
+    combinator: 'and' | 'or';
+    conditions: Array<RuleCondition | RuleGroup>;
+}
+interface RuleAction {
+    id: string;
+    type: string;
+    parameters: Record<string, JsonValue>;
+}
+interface RuleDefinition {
+    when: RuleGroup;
+    then: RuleAction[];
+}
+/** The built-in checks of `validateRuleDefinition`; each can be reworded or turned off (HAR-1618). */
+type RuleCheck = 'duplicateId' | 'maxDepth' | 'emptyGroup' | 'missingField' | 'missingOperator' | 'noActions' | 'missingActionType';
+interface RuleValidationIssue {
+    path: string;
+    message: string;
+    /** Which built-in check raised it. Absent on issues from the consumer's own `validate`. */
+    check?: RuleCheck;
+}
+/** The built-in messages. `{id}` is the duplicated id, `{max}` the depth limit. */
+declare const DEFAULT_RULE_VALIDATION_MESSAGES: Record<RuleCheck, string>;
+interface RuleValidationOptions {
+    /** Replace individual messages (a translation). */
+    messages?: Partial<Record<RuleCheck, string>>;
+    /**
+     * `false` turns a check off: `{ emptyGroup: false }` for a rule that may have no condition
+     * (a catch-all), `{ noActions: false, missingActionType: false }` for conditions without actions.
+     */
+    checks?: Partial<Record<RuleCheck, boolean>>;
+}
+declare function isRuleGroup(node: RuleCondition | RuleGroup): node is RuleGroup;
+declare function ruleDepth(group: RuleGroup): number;
+declare function findRuleNodeDepth(group: RuleGroup, id: string, depth?: number): number | undefined;
+declare function mapRuleGroup(group: RuleGroup, id: string, update: (node: RuleCondition | RuleGroup) => RuleCondition | RuleGroup): RuleGroup;
+declare function appendRuleNode(group: RuleGroup, parentId: string, node: RuleCondition | RuleGroup, maxDepth?: number): RuleGroup;
+declare function removeRuleNode(group: RuleGroup, id: string): RuleGroup;
+declare function moveRuleNode(group: RuleGroup, id: string, direction: -1 | 1): RuleGroup;
+/** Set `combinator` on a group and on every group nested in it. */
+declare function setRuleCombinator(group: RuleGroup, combinator: 'and' | 'or'): RuleGroup;
+declare function validateRuleDefinition(value: RuleDefinition, maxDepth?: number, options?: RuleValidationOptions): RuleValidationIssue[];
+/** The words of the `summarizeRule` sentence. `{conditions}` and `{actions}` are filled in. */
+interface RuleSummaryWords {
+    sentence: string;
+    /** For a rule with no actions to name (a conditions-only rule). */
+    sentenceConditionsOnly: string;
+    noConditions: string;
+    noActions: string;
+    and: string;
+    or: string;
+}
+declare const DEFAULT_RULE_SUMMARY_WORDS: RuleSummaryWords;
+declare function summarizeRule(value: RuleDefinition, labels?: {
+    fields?: Record<string, string>;
+    operators?: Record<string, string>;
+    actions?: Record<string, string>;
+    /** Translate the sentence itself. Default: English. */
+    words?: Partial<RuleSummaryWords>;
+    /** Leave the actions out of the sentence. */
+    conditionsOnly?: boolean;
+}): string;
+
+interface RuleValueEditorProps {
+    condition: RuleCondition;
+    onChange: (value: JsonValue | undefined) => void;
+    disabled?: boolean;
+}
+interface RuleFieldDefinition {
+    id: string;
+    label: string;
+    description?: string;
+    operators?: string[];
+    renderValueEditor?: (props: RuleValueEditorProps) => ReactNode;
+}
+interface RuleOperatorDefinition {
+    id: string;
+    label: string;
+    requiresValue?: boolean;
+}
+interface RuleActionDefinition {
+    id: string;
+    label: string;
+    renderParameters?: (action: RuleAction, onChange: (parameters: Record<string, JsonValue>) => void, disabled: boolean) => ReactNode;
+}
+/**
+ * Every word the rule builder renders (TENSOR RX-125, UIX-12). `{item}` is one of
+ * `itemGroup` / `itemCondition` / `itemAction`; `{field}` a field label; `{count}` a number.
+ * The `issue…` keys are the built-in validation messages (`{id}` the duplicated id, `{max}`
+ * the depth limit) and the `summary…` / `and` / `or` keys the words of the
+ * `readOnly="summary"` sentence (HAR-1618). Translate once for a subtree with
+ * `UixLabelsProvider labels={{ ruleBuilder: … }}`.
+ */
+interface RuleBuilderLabels {
+    region: string;
+    summary: string;
+    when: string;
+    group: string;
+    match: string;
+    all: string;
+    any: string;
+    field: string;
+    operator: string;
+    valueFor: string;
+    itemGroup: string;
+    itemCondition: string;
+    itemAction: string;
+    moveUp: string;
+    moveUpNamed: string;
+    moveDown: string;
+    moveDownNamed: string;
+    remove: string;
+    removeNamed: string;
+    then: string;
+    actionType: string;
+    valid: string;
+    issuesOne: string;
+    issuesMany: string;
+    summaryIssuesOne: string;
+    summaryIssuesMany: string;
+    addCondition: string;
+    addGroup: string;
+    addAction: string;
+    issueDuplicateId: string;
+    issueMaxDepth: string;
+    issueEmptyGroup: string;
+    issueMissingField: string;
+    issueMissingOperator: string;
+    issueNoActions: string;
+    issueMissingActionType: string;
+    summarySentence: string;
+    summarySentenceConditionsOnly: string;
+    summaryNoConditions: string;
+    summaryNoActions: string;
+    and: string;
+    or: string;
+}
+declare const DEFAULT_RULE_BUILDER_LABELS: RuleBuilderLabels;
+interface RuleBuilderProps {
+    value: RuleDefinition;
+    onChange: (value: RuleDefinition) => void;
+    fields: RuleFieldDefinition[];
+    operators: RuleOperatorDefinition[];
+    /** The action types of the "Then" block. Not needed with `conditionsOnly`. */
+    actions?: RuleActionDefinition[];
+    maxDepth?: number;
+    /**
+     * `true`: the same builder with every control disabled and no add, move or remove buttons.
+     * `'summary'`: one sentence instead of the controls (what `readOnly` rendered up to 2.31.0;
+     * its words are the `summary…`, `and` and `or` labels).
+     */
+    readOnly?: boolean | 'summary';
+    /**
+     * Edit conditions only (HAR-1618): no "Then" block and no "Add action", and the two action
+     * checks (`noActions`, `missingActionType`) are off. `value.then` is passed through untouched.
+     */
+    conditionsOnly?: boolean;
+    /**
+     * Fix every group to this combinator, for a stored shape that is a flat AND-list. The Match
+     * choice becomes plain text ("Match all (AND)"), new groups get this combinator, and every
+     * `onChange` carries it on all groups, so the other value is never emitted.
+     */
+    combinator?: 'and' | 'or';
+    /** Hide the Match control (and its text when `combinator` fixes it). */
+    hideCombinator?: boolean;
+    /**
+     * `false` hides "Add group". It is hidden as well when `maxDepth` is 1, where it could never
+     * be used. Default `true`.
+     */
+    allowGroups?: boolean;
+    /**
+     * Turn built-in checks off: `{ emptyGroup: false }` for a rule that may have no condition
+     * (a catch-all), `{ noActions: false }` for a rule that may do nothing. Their messages are
+     * the `issue…` labels.
+     */
+    checks?: Partial<Record<RuleCheck, boolean>>;
+    /** Extra issues; they are appended to the built-in ones. */
+    validate?: (value: RuleDefinition) => RuleValidationIssue[];
+    className?: string;
+    /** @deprecated use `labels.addCondition` */
+    addConditionLabel?: string;
+    /** @deprecated use `labels.addGroup` */
+    addGroupLabel?: string;
+    /** @deprecated use `labels.addAction` */
+    addActionLabel?: string;
+    labels?: Partial<RuleBuilderLabels>;
+}
+/** Declarative controlled when-conditions-to-actions editor with bounded nesting. */
+declare function RuleBuilder({ value, onChange, fields, operators, actions, maxDepth, readOnly, conditionsOnly, combinator, hideCombinator, allowGroups, checks, validate, className, addConditionLabel, addGroupLabel, addActionLabel, labels: labelOverrides, }: RuleBuilderProps): react.JSX.Element;
+
+/** File helpers shared by `FileUpload` and `Attachment` (HAR-984/985). Pure. */
+interface FileSizeOptions {
+    /**
+     * `1000` (default): decimal, as file managers on macOS and most of the web show sizes
+     * (1 MB = 1,000,000 bytes). `1024`: binary, as Windows and many servers count them
+     * (1 MB = 1,048,576 bytes) — use it when the rest of the product does, so one file never
+     * shows two sizes (HAR-1630).
+     */
+    base?: 1000 | 1024;
+    /**
+     * The five unit labels, bytes first. Default `['B', 'KB', 'MB', 'GB', 'TB']` for both bases;
+     * pass `['B', 'KiB', 'MiB', 'GiB', 'TiB']` to mark base 1024 the IEC way, or localised ones.
+     */
+    units?: readonly [string, string, string, string, string];
+}
+/** A product's own size formatter for `FileUpload` and `Attachment` (`formatSize`). */
+type FileSizeFormatter = (bytes: number, locale?: string) => string;
+/**
+ * "1.2 MB", "340 KB", "12 B" in the locale's number format. Base 1000 unless `options.base`
+ * is 1024.
+ */
+declare function formatFileSize(bytes: number, locale?: string, options?: FileSizeOptions): string;
+/** Whether a file matches an `accept` list (".pdf,image/*,application/zip"). An empty list accepts all. */
+declare function fileMatchesAccept(file: {
+    name: string;
+    type?: string;
+}, accept?: string): boolean;
+type FileRejectionReason = 'type' | 'size' | 'count';
+interface FileRejection<F = File> {
+    file: F;
+    reason: FileRejectionReason;
+}
+/**
+ * Splits picked files into accepted and rejected (wrong type, over `maxSize` bytes, or beyond
+ * `maxFiles` counting the `existing` ones). Order is kept.
+ */
+declare function partitionFiles<F extends {
+    name: string;
+    type?: string;
+    size: number;
+}>(files: readonly F[], { accept, maxSize, maxFiles, existing }: {
+    accept?: string;
+    maxSize?: number;
+    maxFiles?: number;
+    existing?: number;
+}): {
+    accepted: F[];
+    rejected: FileRejection<F>[];
+};
+/** A coarse kind for a file icon. */
+declare function fileKind(file: {
+    name: string;
+    type?: string;
+}): 'image' | 'video' | 'pdf' | 'sheet' | 'archive' | 'text' | 'other';
+
+type FileUploadStatus = 'queued' | 'uploading' | 'done' | 'error';
+interface FileUploadItem {
+    id: string;
+    name: string;
+    /** Bytes. */
+    size: number;
+    type?: string;
+    status: FileUploadStatus;
+    /** 0–100 while uploading; without it the bar is indeterminate. */
+    progress?: number;
+    /** Why it failed (shown under the name with a Retry button). */
+    error?: ReactNode;
+    /** An object URL or remote URL for an image thumbnail. */
+    previewUrl?: string;
+    /** Alternative text, when the product asks for it (`onAltChange`). */
+    alt?: string;
+}
+interface FileUploadLabels {
+    /** Main line of the drop zone. */
+    title: string;
+    choose: string;
+    /** Shown while a file is dragged over. */
+    drop: string;
+    list: string;
+    remove: string;
+    /** Accessible name of Retry. `{name}`. */
+    retry: string;
+    /** Visible text of Retry. */
+    retryShort: string;
+    queued: string;
+    /** `{progress}`. */
+    uploading: string;
+    done: string;
+    failed: string;
+    /** `{name}` — set `alt` for images. */
+    alt: string;
+    /** `{count}` files added. */
+    added: string;
+    /** `{name}`, `{accept}`. */
+    wrongType: string;
+    /** `{name}`, `{max}`. */
+    tooLarge: string;
+    /** `{name}`, `{max}`. */
+    tooMany: string;
+}
+declare const DEFAULT_FILE_UPLOAD_LABELS: FileUploadLabels;
+interface FileUploadProps {
+    /** The files so far, with their upload state (controlled). */
+    items: readonly FileUploadItem[];
+    /**
+     * Called with the files that passed `accept`, `maxSize` and `maxFiles`, and the ones that did
+     * not. Add accepted files to `items` and upload them; the component never uploads.
+     */
+    onFilesAdded: (accepted: File[], rejected: FileRejection[]) => void;
+    onRemove?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    /** Ask for alt text on image items (MOTUS photo intake). */
+    onAltChange?: (id: string, alt: string) => void;
+    /** Accepted types, as for `<input accept>`. */
+    accept?: string;
+    /** Largest file in bytes. */
+    maxSize?: number;
+    /** Most files in `items`. */
+    maxFiles?: number;
+    /** Default true. */
+    multiple?: boolean;
+    /** Open the camera on phones (`user` or `environment`). */
+    capture?: 'user' | 'environment';
+    disabled?: boolean;
+    /** Second line of the drop zone, e.g. "PDF or images, up to 20 MB". */
+    hint?: ReactNode;
+    locale?: string;
+    /** Count sizes in 1024s (1 MB = 1,048,576 bytes) instead of 1000s. Default `1000`. */
+    sizeBase?: 1000 | 1024;
+    /** The product's own size formatter; it replaces `formatFileSize` (and `sizeBase`). */
+    formatSize?: FileSizeFormatter;
+    /**
+     * Words for this instance. Each one defaults to `UixLabelsProvider` `fileUpload`, then to
+     * English, so one provider translates every upload below it (HAR-1630).
+     */
+    labels?: Partial<FileUploadLabels>;
+    className?: string;
+}
+/**
+ * Drop zone, file picker and upload list (HAR-984; TENSOR C15, MOTUS C-7, MEDx S18/S19). The
+ * product owns the upload: it receives validated `File`s and reports progress, success and
+ * failure through `items`. Keyboard users get a real button; drop is an extra, not the only way.
+ */
+declare function FileUpload({ items, onFilesAdded, onRemove, onRetry, onAltChange, accept, maxSize, maxFiles, multiple, capture, disabled, hint, locale, sizeBase, formatSize, labels: labelOverrides, className, }: FileUploadProps): react.JSX.Element;
+
+/**
+ * The words of an `Attachment` row. In a module of its own, with no "use client": the
+ * server-renderable `Attachment` and its client parts both read it, and a server component can
+ * still import the defaults as plain values.
+ */
+interface AttachmentLabels {
+    /** Remove button. `{name}`. */
+    remove: string;
+    /** Download link name when `download` is set. `{name}`. */
+    download: string;
+    loading: string;
+    forbidden: string;
+}
+declare const DEFAULT_ATTACHMENT_LABELS: AttachmentLabels;
+
 /**
  * Kit chrome strings by component (HAR-1358; TENSOR C20, MOTUS executive summary #3).
  * Each entry overrides that component's English defaults for every instance below the
@@ -686,6 +1799,20 @@ interface UixLabels {
     schedulingCalendar?: Partial<SchedulingCalendarLabels>;
     dateRangePicker?: Partial<DateRangePickerLabels>;
     schedulingTimeline?: Partial<SchedulingTimelineLabels>;
+    textDiff?: Partial<TextDiffLabels>;
+    filterEditor?: Partial<FilterEditorLabels>;
+    select?: Partial<SelectLabels>;
+    ruleBuilder?: Partial<RuleBuilderLabels>;
+    fileUpload?: Partial<FileUploadLabels>;
+    attachment?: Partial<AttachmentLabels>;
+    /** `remove`: the name of a removable chip's × button; `{label}` is the chip text. */
+    chip?: {
+        remove?: string;
+    };
+    /** `dismiss`: the name of a dismissible alert's × button. */
+    alert?: {
+        dismiss?: string;
+    };
     /** Read by `useUixLabels()` callers; `Pagination` itself is server-safe and takes `labels`. */
     pagination?: Partial<PaginationLabels>;
     /** Read by `useUixLabels()` callers; `BulkBar` itself is server-safe and takes `label`. */
@@ -822,6 +1949,10 @@ interface SearchSuggestProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onCha
     autoFocus?: boolean;
     /** Form field name of the input. */
     name?: string;
+    /** Id of the input itself (for a `<label for>` / `Field htmlFor`); `id` stays on the wrapper. */
+    inputId?: string;
+    /** `aria-describedby` of the input (hint and error text from a `Field`). */
+    inputDescribedBy?: string;
 }
 /**
  * A search field with a suggestion list underneath: the "search and jump" pattern of Windows
@@ -830,7 +1961,58 @@ interface SearchSuggestProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onCha
  * (`aria-activedescendant`), Enter opens it (the first row when none is active), Escape closes the
  * list and a second Escape clears the text.
  */
-declare function SearchSuggest({ value, onValueChange, options, onSelect, label, placeholder, highlight, heading, headingAction, footer, loading, loadingLabel, empty, error, shortcutHint, clearLabel: clearLabelProp, status, size, open: openProp, strategy, onOpenChange, inputRef, autoFocus, name, className, onBlur, ...props }: SearchSuggestProps): react.JSX.Element;
+declare function SearchSuggest({ value, onValueChange, options, onSelect, label, placeholder, highlight, heading, headingAction, footer, loading, loadingLabel, empty, error, shortcutHint, clearLabel: clearLabelProp, status, size, open: openProp, strategy, onOpenChange, inputRef, autoFocus, name, inputId, inputDescribedBy, className, onBlur, ...props }: SearchSuggestProps): react.JSX.Element;
+
+interface EntityPickerLabels {
+    /** Accessible name of the search field while picking. */
+    search: string;
+    loading: string;
+    empty: string;
+    error: string;
+    retry: string;
+    /** Clears the chosen record. `{title}`. */
+    clear: string;
+    /** Names the chosen-record button that reopens the search. `{label}`, `{title}`. */
+    change: string;
+    /** Shown in the field when nothing is chosen. */
+    none: string;
+    /** Polite count after a search. `{count}`. */
+    results: string;
+}
+declare const DEFAULT_ENTITY_PICKER_LABELS: EntityPickerLabels;
+interface EntityPickerProps {
+    /** The chosen record, or null. */
+    value: SearchSuggestOption | null;
+    onValueChange: (next: SearchSuggestOption | null) => void;
+    /** Finds records for the query; a rejection shows the error state with a Retry row. */
+    onSearch: (query: string) => Promise<readonly SearchSuggestOption[]>;
+    /** The field's name (the visible label usually comes from a surrounding `Field`). */
+    label: string;
+    /** Id of the control, for `Field htmlFor`/`label for`. */
+    id?: string;
+    /** Hidden form value: the chosen record's id. */
+    name?: string;
+    placeholder?: string;
+    /** Search only from this many characters. Default 0 (an empty query lists suggestions). */
+    minQueryLength?: number;
+    /** Debounce before searching, in ms. Default 250. */
+    delay?: number;
+    disabled?: boolean;
+    invalid?: boolean;
+    /** Ids of hint/error text (from `Field`). */
+    'aria-describedby'?: string;
+    /** How the chosen record shows in the field. Default: title, then the last breadcrumb. */
+    renderValue?: (option: SearchSuggestOption) => ReactNode;
+    labels?: Partial<EntityPickerLabels>;
+    className?: string;
+}
+/**
+ * A form field that holds one record found by an async search (HAR-1366; TENSOR B28/C5
+ * `entity-picker.tsx`, MOTUS B-P10): the chosen record shows as the field's value with a
+ * clear ×; choosing again or typing opens a `SearchSuggest` list with loading, empty and error
+ * states, and Retry is a list row, so the keyboard reaches it. Stale results are ignored.
+ */
+declare function EntityPicker({ value, onValueChange, onSearch, label, id, name, placeholder, minQueryLength, delay, disabled, invalid, 'aria-describedby': describedBy, renderValue, labels: labelOverrides, className, }: EntityPickerProps): react.JSX.Element;
 
 /** One run of a result's text, emphasised or not. */
 interface SearchSegment {
@@ -856,11 +2038,6 @@ interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
 }
 declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
 
-interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
-    size?: 'sm' | 'md';
-}
-declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
-
 interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
     label?: ReactNode;
     indeterminate?: boolean;
@@ -922,7 +2099,8 @@ interface ConfirmDialogProps {
     description?: ReactNode;
     confirmLabel: ReactNode;
     cancelLabel: ReactNode;
-    closeLabel: string;
+    /** Accessible name of the close button. Default: `UixLabelsProvider` `modal.close`, then "Close dialog". */
+    closeLabel?: string;
     onConfirm: () => void | Promise<void>;
     onCancel: () => void;
     pending?: boolean;
@@ -989,13 +2167,33 @@ interface PromptDialogProps {
     placeholder?: string;
     submitLabel: ReactNode;
     cancelLabel: ReactNode;
-    closeLabel: string;
+    /** Accessible name of the close button. Default: `UixLabelsProvider` `modal.close`, then "Close dialog". */
+    closeLabel?: string;
     onSubmit: (value: string) => void | Promise<void>;
     onCancel: () => void;
     validate?: (value: string) => ReactNode | undefined;
     pending?: boolean;
+    /**
+     * Ask for a longer answer in a textarea (a reason, a note); a number sets its rows, `true`
+     * is 4. Enter adds a line there, so the form is sent with the submit button or Ctrl/⌘+Enter
+     * (HAR-1614).
+     */
+    multiline?: boolean | number;
+    /**
+     * The answer confirms something that cannot be taken back (a forced import): the submit
+     * button is the danger button and the dialog is an `alertdialog`.
+     */
+    destructive?: boolean;
+    /**
+     * Why the last submit failed, from the server. Shown under the field (`role="alert"`) and
+     * tied to it; the dialog stays open. A message from `validate` takes its place while the
+     * value is invalid.
+     */
+    error?: ReactNode;
+    /** Default: `'alertdialog'` when `destructive`, else `'dialog'`. */
+    role?: 'dialog' | 'alertdialog';
 }
-declare function PromptDialog({ open, title, description, inputLabel, defaultValue, placeholder, submitLabel, cancelLabel, closeLabel, onSubmit, onCancel, validate, pending }: PromptDialogProps): react.JSX.Element;
+declare function PromptDialog({ open, title, description, inputLabel, defaultValue, placeholder, submitLabel, cancelLabel, closeLabel, onSubmit, onCancel, validate, pending, multiline, destructive, error: submitError, role, }: PromptDialogProps): react.JSX.Element;
 
 interface DrawerProps extends Omit<HTMLAttributes<HTMLDialogElement>, 'title'> {
     /** TENSOR RX-125 (UIX-04): translatable; English default. */
@@ -1037,6 +2235,47 @@ interface PeekProps extends Omit<HTMLAttributes<HTMLDialogElement>, 'title'> {
 }
 declare function Peek({ open, onClose, title, children, footer, onNavPrev, onNavNext, hint, previousLabel: previousLabelProp, nextLabel: nextLabelProp, closeLabel: closeLabelProp, className, onClick, ...rest }: PeekProps): react.JSX.Element;
 
+interface LightboxItem {
+    src: string;
+    /** Alternative text for an image; the video's name for a video. */
+    alt: string;
+    caption?: ReactNode;
+    kind?: 'image' | 'video';
+    /** Intrinsic size, so an SVG or a slow image keeps its box. */
+    width?: number;
+    height?: number;
+}
+interface LightboxLabels {
+    region: string;
+    previous: string;
+    next: string;
+    close: string;
+    /** `{index}`, `{total}`. */
+    counter: string;
+    zoomIn: string;
+    zoomOut: string;
+}
+declare const DEFAULT_LIGHTBOX_LABELS: LightboxLabels;
+interface LightboxProps {
+    items: readonly LightboxItem[];
+    /** The item on show (0-based). */
+    index: number;
+    onIndexChange: (index: number) => void;
+    open: boolean;
+    onClose: () => void;
+    /** Wrap from the last item to the first. Default false. */
+    loop?: boolean;
+    labels?: Partial<LightboxLabels>;
+    className?: string;
+}
+/**
+ * A full-screen media viewer over `.uix-lightbox` (HAR-1367; TENSOR C12 `capture-viewer.tsx`,
+ * MOTUS C-8 programme gallery): previous/next buttons, ←/→ and Home/End, swipe on touch, an
+ * announced "n of total" counter, a caption, and a fit/actual-size toggle. Native `<dialog>`,
+ * so focus stays inside and Escape closes; focus returns to the control that opened it.
+ */
+declare function Lightbox({ items, index, onIndexChange, open, onClose, loop, labels: labelOverrides, className }: LightboxProps): react.JSX.Element;
+
 interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
     title?: ReactNode;
     /** Element for the title — pick a real heading to slot the card into the page outline (UIX-A11Y-4). Default `div` keeps legacy rendering. */
@@ -1070,6 +2309,62 @@ interface CardLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 't
 /** A whole-card anchor with visible hover and keyboard focus affordances. */
 declare function CardLink({ title, subtitle, headerAction, footer, children, className, ...props }: CardLinkProps): react.JSX.Element;
 
+/** Columns at one width. */
+type DashboardGridColumnCount = 1 | 2 | 3 | 4;
+/**
+ * A width of the GRID itself (a container query), not of the viewport:
+ * `base` any width, `sm` ≥ 36rem, `md` ≥ 48rem, `lg` ≥ 60rem, `xl` ≥ 80rem.
+ */
+type DashboardGridBreakpoint = 'base' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * One column count for every width, or a count per breakpoint. A breakpoint you leave out keeps
+ * the count of the next smaller one, and a missing `base` is 1.
+ */
+type DashboardGridColumns = DashboardGridColumnCount | Partial<Record<DashboardGridBreakpoint, DashboardGridColumnCount>>;
+/** How much of the row an item takes. `2` clamps to the columns there are; `full` is always the whole row. */
+type DashboardGridSpan = 1 | 2 | 'full';
+/** Space between items: `sm` --uix-space-3, `md` --uix-space-4, `lg` --uix-space-6. */
+type DashboardGridGap = 'sm' | 'md' | 'lg';
+interface DashboardGridProps extends HTMLAttributes<HTMLDivElement> {
+    /** Default: 1 column, 2 from `sm`, 3 from `lg` (of the grid's own width). */
+    columns?: DashboardGridColumns;
+    /** Default `md`. */
+    gap?: DashboardGridGap;
+}
+interface DashboardGridItemProps extends HTMLAttributes<HTMLDivElement> {
+    /** Default `1`. */
+    span?: DashboardGridSpan;
+}
+/**
+ * The class list of a dashboard grid, for markup you render yourself (a server template, or a
+ * drag-and-drop library's own element). Same output as `<DashboardGrid>`.
+ */
+declare function dashboardGridClassName(columns?: DashboardGridColumns, gap?: DashboardGridGap): string;
+/** The class list of a dashboard grid item, for markup you render yourself. */
+declare function dashboardGridItemClassName(span?: DashboardGridSpan): string;
+/**
+ * A cell of a {@link DashboardGrid}: one column, two, or the full row. It is an inline-size
+ * container (container name: uix-dashboard-grid-item), so its content can size from it, e.g. a Chart with
+ * `height="clamp(160px, 40cqi, 360px)"`. Widgets in one row share a height.
+ */
+declare const DashboardGridItem: react.ForwardRefExoticComponent<DashboardGridItemProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * The layout grid for dashboard widgets (HAR-1555). The column count follows the grid's own
+ * width, so it adapts to a sidebar as well as to the screen. Pure layout: drag-and-drop,
+ * persistence and widget chrome stay in the product. Server-renderable.
+ *
+ * ```tsx
+ * <DashboardGrid columns={{ base: 1, sm: 2, lg: 3 }}>
+ *   <DashboardGrid.Item><Stat … /></DashboardGrid.Item>
+ *   <DashboardGrid.Item span={2}>…</DashboardGrid.Item>
+ *   <DashboardGrid.Item span="full"><Chart … /></DashboardGrid.Item>
+ * </DashboardGrid>
+ * ```
+ */
+declare const DashboardGrid: react.ForwardRefExoticComponent<DashboardGridProps & react.RefAttributes<HTMLDivElement>> & {
+    Item: react.ForwardRefExoticComponent<DashboardGridItemProps & react.RefAttributes<HTMLDivElement>>;
+};
+
 interface BreadcrumbItem {
     id?: string;
     label: ReactNode;
@@ -1193,6 +2488,12 @@ interface CollapsibleSectionProps extends Omit<DetailsHTMLAttributes<HTMLDetails
     title: ReactNode;
     summary?: ReactNode;
     children?: ReactNode;
+    /**
+     * Open when first rendered. With `persistKey`, what the person last chose wins over it:
+     * "open by default, but remember" (HAR-1628). `open` is the same starting state and also
+     * re-applies whenever the parent changes it.
+     */
+    defaultOpen?: boolean;
     /**
      * Mount the body only while it is needed (HAR-1352; TENSOR B32): `true` mounts it while
      * open and unmounts it on close; `'keep'` mounts it on first open and keeps it. For
@@ -1200,12 +2501,33 @@ interface CollapsibleSectionProps extends Omit<DetailsHTMLAttributes<HTMLDetails
      */
     lazy?: boolean | 'keep';
     /**
-     * Remember the open state for the session under this key (`sessionStorage`,
-     * `uix:collapsible:<key>`). Applied after mount, so the server HTML uses `open`.
+     * Remember the open state under this key (`uix:collapsible:<key>`), in `persistStorage`.
+     * Applied after mount, so the server HTML uses `open` / `defaultOpen`; a remembered state
+     * then replaces either.
      */
     persistKey?: string;
-    /** Each new value opens the section and scrolls it into view ("jump to SLA"). */
+    /**
+     * Where `persistKey` keeps the state: `'session'` (`sessionStorage`, this tab until it
+     * closes) or `'local'` (`localStorage`, across sessions). Default `'session'`.
+     */
+    persistStorage?: 'session' | 'local';
+    /**
+     * Each new value opens the section, scrolls it into view and moves focus to its summary
+     * ("jump to SLA"). A value already set when the section mounts is honoured too (a deep link
+     * that lands on a closed section); `undefined` and `0` mean "no request yet", so a counter
+     * that starts at 0 does not open anything.
+     */
     openRequest?: number;
+    /**
+     * A quiet row for a section inside a card: no border or background of its own, tighter
+     * padding, a rule between neighbouring compact sections.
+     */
+    compact?: boolean;
+    /**
+     * Render the title as a heading of this level, and make the body a `role="region"` named by
+     * it. Leave unset for a section that should stay out of the page outline.
+     */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
 }
 /**
  * A `<details>` disclosure. Without `lazy`, `persistKey` or `openRequest` it is a plain,
@@ -1256,6 +2578,10 @@ interface DescriptionListItem {
     id?: string;
     term: ReactNode;
     description: ReactNode;
+    /** Attributes for this row's `<dt>` (an `id` to anchor to, `data-*`). */
+    termProps?: HTMLAttributes<HTMLElement>;
+    /** Attributes for this row's `<dd>`. */
+    descriptionProps?: HTMLAttributes<HTMLElement>;
 }
 interface DescriptionListProps extends HTMLAttributes<HTMLDListElement> {
     items?: DescriptionListItem[];
@@ -1265,15 +2591,27 @@ declare function DescriptionList({ items, children, className, ...props }: Descr
 interface DescriptionItemProps {
     term: ReactNode;
     children?: ReactNode;
+    /**
+     * Attributes for the `<dt>`: an `id` a deep link or `aria-describedby` points at, `data-*`,
+     * a `className` (HAR-1628). The pair has no wrapper element, so this is where they go.
+     */
+    termProps?: HTMLAttributes<HTMLElement>;
+    /** Attributes for the `<dd>`. */
+    descriptionProps?: HTMLAttributes<HTMLElement>;
 }
 /**
  * One hand-authored row. Renders a `<dt>`/`<dd>` fragment so the pair lands as
  * direct grid children of the enclosing `<DescriptionList>` (never wrap it in
  * an element — that breaks the two-column alignment).
  */
-declare function DescriptionItem({ term, children }: DescriptionItemProps): react.JSX.Element;
+declare function DescriptionItem({ term, children, termProps, descriptionProps }: DescriptionItemProps): react.JSX.Element;
 
-interface TabsProps {
+/**
+ * Besides its own props, `Tabs` takes the HTML attributes of the `role="tablist"` element and
+ * renders them there, in both overflow modes: `aria-label` / `aria-labelledby` to name the
+ * tablist (HAR-1600), `id`, `data-*`. `role` stays `tablist`.
+ */
+interface TabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'role'> {
     variant?: 'line' | 'enclosed' | 'pill';
     value?: string;
     onChange?: (value: string) => void;
@@ -1293,7 +2631,7 @@ interface TabsProps {
      */
     activation?: 'automatic' | 'manual';
 }
-declare function Tabs({ variant, value, onChange, children, className, overflow, activation }: TabsProps): react.JSX.Element;
+declare function Tabs({ variant, value, onChange, children, className, overflow, activation, onKeyDown: onKeyDownProp, ...listProps }: TabsProps): react.JSX.Element;
 interface TabProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'onChange'> {
     value: string;
     children?: ReactNode;
@@ -1500,23 +2838,117 @@ interface NavFavouritesProps {
  */
 declare function NavFavourites({ items, collapsed, onToggleCollapsed, onRemove, onReorder, labels, emptyReason, className, }: NavFavouritesProps): react.JSX.Element;
 
+interface AttachmentProps extends Omit<LiHTMLAttributes<HTMLLIElement>, 'children'> {
+    /** File name as the user should read it (decrypted, if the product stores it encrypted). */
+    name: string;
+    /** Bytes. */
+    size?: number;
+    /** MIME type, for the file glyph. */
+    type?: string;
+    /** Opens or downloads the file. The name becomes the link. */
+    href?: string;
+    /** Download instead of opening; a string sets the saved file name. */
+    download?: boolean | string;
+    renderLink?: UixRenderLink;
+    /** A quieter line: who added it and when. */
+    meta?: ReactNode;
+    /** A state slot after the name, e.g. `<StatusPill tone="warning">Scanning</StatusPill>`. */
+    state?: ReactNode;
+    /** Replaces the file glyph (e.g. an image thumbnail). */
+    thumbnail?: ReactNode;
+    /** Adds a remove button; confirm destructive removals in the handler (`ConfirmDialog`/`Popconfirm`). */
+    onRemove?: () => void;
+    /** `loading` (no link yet), `error` (shows `error`), `forbidden` (no link, a reason). */
+    status?: 'ready' | 'loading' | 'error' | 'forbidden';
+    error?: ReactNode;
+    /** Extra actions at the end of the row. */
+    actions?: ReactNode;
+    locale?: string;
+    /** Count sizes in 1024s (1 MB = 1,048,576 bytes) instead of 1000s. Default `1000`. */
+    sizeBase?: 1000 | 1024;
+    /** The product's own size formatter; it replaces `formatFileSize` (and `sizeBase`). */
+    formatSize?: FileSizeFormatter;
+    /**
+     * Words for this row. Each one defaults to `UixLabelsProvider` `attachment`, then to English,
+     * so one provider translates every row below it (HAR-1630).
+     */
+    labels?: Partial<AttachmentLabels>;
+}
+/**
+ * One file row (HAR-985; TENSOR C15/B12 `attachments-panel-view.tsx`, MEDx S19/S52): glyph or
+ * thumbnail, the name as a link, size and meta, a state slot, and remove. Server-renderable:
+ * the words that come from `UixLabelsProvider` are rendered by small client parts.
+ */
+declare function Attachment({ name, size, type, href, download, renderLink, meta, state, thumbnail, onRemove, status, error, actions, locale, sizeBase, formatSize, labels, className, ...props }: AttachmentProps): react.JSX.Element;
+interface AttachmentListProps extends HTMLAttributes<HTMLUListElement> {
+    /** Names the list, e.g. "Attachments (3)". */
+    label?: string;
+    children?: ReactNode;
+}
+/** A list of `Attachment` rows. */
+declare function AttachmentList({ label, className, children, ...props }: AttachmentListProps): react.JSX.Element;
+
 type AlertTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
 interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
     tone?: AlertTone;
     title?: ReactNode;
     icon?: ReactNode;
     children?: ReactNode;
+    /**
+     * A trailing slot for what the alert offers to do: a `Button`, a link (HAR-1614). It keeps
+     * its place at the end while the text beside it wraps.
+     */
+    actions?: ReactNode;
+    /**
+     * Adds a × at the end. The alert does not hide itself: stop rendering it in the handler, and
+     * move focus somewhere sensible if the alert held it.
+     */
+    onDismiss?: () => void;
+    /** Accessible name of the ×. Default: `UixLabelsProvider` `alert.dismiss`, then "Dismiss". */
+    dismissLabel?: string;
 }
-declare function Alert({ tone, title, icon, children, className, ...props }: AlertProps): react.JSX.Element;
+/**
+ * Inline banner over `.uix-alert`. The ref is the alert element, so a form can move focus to
+ * its error message (give it `tabIndex={-1}`).
+ */
+declare const Alert: react.ForwardRefExoticComponent<AlertProps & react.RefAttributes<HTMLDivElement>>;
 
 interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
-    size?: 'md' | 'lg';
+    /** `sm` 16 px (inline, beside text or inside a 24 px control), `md` 20 px (default), `lg` 32 px. */
+    size?: 'sm' | 'md' | 'lg';
     accent?: boolean;
     /** Announced loading text (default "Loading…"). */
     label?: string;
 }
 declare function Spinner({ size, accent, label, className, ...props }: SpinnerProps): react.JSX.Element;
 
+type HeartbeatState = 'live' | 'idle' | 'warning' | 'danger';
+interface HeartbeatProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    /**
+     * `live` (default): a green dot with a pulsing ring. `warning` / `danger`: the same in that
+     * tone. `idle`: a grey dot, no ring.
+     */
+    state?: HeartbeatState;
+    /**
+     * What the dot means, for assistive technology ("Live", "Connection lost"). Without it the
+     * dot is decorative (`aria-hidden`): say the state in text beside it, as `LiveIndicator` does.
+     */
+    label?: string;
+}
+/**
+ * The pulsing status dot over `.uix-heartbeat` (HAR-1606), so products stop hand-writing its
+ * three spans. Decorative unless it has a `label`. The ring stops under
+ * `prefers-reduced-motion` (the kit's global motion guard); the dot and its colour stay.
+ */
+declare function Heartbeat({ state, label, className, ...props }: HeartbeatProps): react.JSX.Element;
+interface LiveIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    state?: HeartbeatState;
+    /** The state in words: "Live", "Paused", "Reconnecting…". It is what a screen reader gets. */
+    children?: ReactNode;
+}
+/** A `Heartbeat` with its state in text beside it, over `.uix-live`. */
+declare function LiveIndicator({ state, children, className, ...props }: LiveIndicatorProps): react.JSX.Element;
+
 /**
  * The imperative toast queue behind `toast()` (HAR-1363; TENSOR A2/C3, MOTUS A3/A4/C-13).
  * Plain module state, no React: mutation helpers and server-action wrappers can call
@@ -1730,14 +3162,20 @@ declare function Highlighted({ text, query }: HighlightedProps): react.JSX.Eleme
 
 type PillTone = 'neutral' | 'success' | 'info' | 'warning' | 'danger' | 'critical' | 'muted' | 'attention' | 'overdue' | 'sla-ok' | 'sla-at-risk' | 'sla-breached' | 'p1' | 'p2' | 'p3' | 'p4' | 'p5';
 type PillTreatment = 'filled' | 'outline';
+type PillSize = 'sm' | 'md' | 'lg';
 interface StatusPillProps extends HTMLAttributes<HTMLSpanElement> {
     tone?: PillTone;
     /** 'filled' (default) = tinted wash; 'outline' = transparent fill + tone-tinted border. */
     treatment?: PillTreatment;
+    /**
+     * `sm` for a dense table cell or beside small text, `lg` for a page header (the public status
+     * page). Default `md`, the size every pill had before (HAR-1614).
+     */
+    size?: PillSize;
     dot?: boolean;
     children?: ReactNode;
 }
-declare function StatusPill({ tone, treatment, dot, children, className, ...props }: StatusPillProps): react.JSX.Element;
+declare function StatusPill({ tone, treatment, size, dot, children, className, ...props }: StatusPillProps): react.JSX.Element;
 
 interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
     /** 0..max. Ignored when `indeterminate`. */
@@ -1751,8 +3189,12 @@ interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
 }
 declare function Progress({ value, max, indeterminate, label, className, ...props }: ProgressProps): react.JSX.Element;
 
-/** Fill color tone for the meter bar. Defaults to `success` (green). */
-type MeterTone = 'success' | 'warning' | 'danger' | 'attention' | 'overdue';
+/**
+ * Fill color tone for the meter bar. Defaults to `success` (green).
+ * `neutral` and `accent` are for a plain proportion that is neither good nor bad (a poll
+ * option's share of the votes): a grey or brand fill, and no tone word is spoken (HAR-1606).
+ */
+type MeterTone = 'success' | 'warning' | 'danger' | 'attention' | 'overdue' | 'neutral' | 'accent';
 interface MeterProps extends HTMLAttributes<HTMLDivElement> {
     /** Fill level 0–100. Clamped to this range. */
     value?: number;
@@ -1761,7 +3203,7 @@ interface MeterProps extends HTMLAttributes<HTMLDivElement> {
     /** Accessible name — rendered as `aria-label` (an explicit `aria-label` prop wins). */
     label?: string;
     /** TENSOR RX-125 (UIX-04): the spoken tone words; English defaults. */
-    toneLabels?: Partial<Record<Exclude<MeterTone, 'success'>, string>>;
+    toneLabels?: Partial<Record<Exclude<MeterTone, 'success' | 'neutral' | 'accent'>, string>>;
 }
 /** Horizontal utilization / threshold bar backed by `.uix-meter`. */
 declare function Meter({ value, tone, label, toneLabels, className, ...props }: MeterProps): react.JSX.Element;
@@ -1833,13 +3275,26 @@ interface ChipProps extends Omit<HTMLAttributes<HTMLElement>, 'onClick'> {
     /** A link chip. */
     href?: string;
     renderLink?: UixRenderLink;
+    /**
+     * A link chip for the page that is open: `aria-current="page"` and the filled look
+     * (HAR-1632). `pressed` gives the same look but says "toggle button", which a link is not.
+     */
+    current?: boolean;
     /** Adds a × button that removes the chip. */
     onRemove?: () => void;
     /**
      * Accessible name of the × button. `{label}` is replaced by the chip text when it is a
-     * string. Default "Remove {label}"; pass a full name when the text is not a string.
+     * string. Default: `UixLabelsProvider` `chip.remove`, then "Remove {label}"; pass a full name
+     * when the text is not a string.
      */
     removeLabel?: string;
+    /**
+     * Attributes for the body: the element that carries the chip's own action. On a plain chip
+     * that is the chip itself, where the other props already go; on a removable chip the other
+     * props go to the wrapper, so this is how `aria-haspopup`, `aria-expanded`, `aria-controls`
+     * or an `id` reach the button that opens the filter editor (HAR-1632).
+     */
+    bodyProps?: HTMLAttributes<HTMLElement>;
     /** `add` is the dashed "+ Add filter" chip. */
     variant?: 'default' | 'add';
     disabled?: boolean;
@@ -1847,8 +3302,10 @@ interface ChipProps extends Omit<HTMLAttributes<HTMLElement>, 'onClick'> {
 /**
  * Filter, tag and token chip over `.uix-chip` (HAR-1360; TENSOR C7/B34, MOTUS C-6/B-A18).
  * Plain text, a toggle, a link or a button, optionally with a × that removes it.
+ * The ref goes to the body (the button, link or span that carries the chip's action), also on
+ * a removable chip: anchor a popover to it and return focus to it without a DOM lookup.
  */
-declare function Chip({ children, icon, count, pressed, onPressedChange, onClick, href, renderLink, onRemove, removeLabel, variant, disabled, className, ...props }: ChipProps): react.JSX.Element;
+declare const Chip: react.ForwardRefExoticComponent<ChipProps & react.RefAttributes<HTMLElement>>;
 interface ChipGroupProps extends HTMLAttributes<HTMLDivElement> {
     /** Names the group, e.g. "Active filters". */
     label?: string;
@@ -1893,9 +3350,20 @@ declare const DEFAULT_STEP_STATE_LABELS: StepStateLabels;
 interface StepsProps extends HTMLAttributes<HTMLOListElement> {
     /**
      * `horizontal` (default) lays the steps in a row and stacks them below 40rem;
-     * `vertical` always stacks, with descriptions under each title.
+     * `vertical` always stacks, with descriptions under each title. Steps that hold
+     * content (`progress={false}`) are always vertical.
      */
     orientation?: 'horizontal' | 'vertical';
+    /**
+     * `true` (default): a progress indicator. Every step has a state, which is read after its
+     * title, and the current one carries `aria-current="step"`.
+     * `false`: a numbered list of sections that are all on screen at once (an intake form in
+     * four parts). No state is drawn or announced, and each `Step`'s children are its content,
+     * in a group named by the step's title (HAR-1628).
+     */
+    progress?: boolean;
+    /** Render each step's title as a heading of this level (for `progress={false}` sections). */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
     /** Names the list, e.g. "Intake progress". */
     label?: string;
     stateLabels?: Partial<StepStateLabels>;
@@ -1912,16 +3380,29 @@ interface StepProps extends Omit<LiHTMLAttributes<HTMLLIElement>, 'title'> {
     href?: string;
     renderLink?: UixRenderLink;
     onSelect?: () => void;
+    /**
+     * The step's content: fields, text, a table. Rendered under the title in a group named by
+     * it. Meant for `<Steps progress={false}>`; in a progress indicator keep steps to a title
+     * and a description.
+     */
+    children?: ReactNode;
     /** Set by `Steps`. */
     index?: number;
     /** Set by `Steps`. */
     last?: boolean;
     /** Set by `Steps`. */
     stateLabels?: StepStateLabels;
+    /** Set by `Steps`. */
+    progress?: boolean;
+    /** Set by `Steps`. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
 }
-/** Numbered progress through a multi-step flow (HAR-1362; TENSOR C13, MOTUS C-9). */
-declare function Steps({ orientation, label, stateLabels, className, children, ...props }: StepsProps): react.JSX.Element;
-declare function Step({ title, description, state, marker, href, renderLink, onSelect, index, last, stateLabels, className, ...props }: StepProps): react.JSX.Element;
+/**
+ * Numbered progress through a multi-step flow (HAR-1362; TENSOR C13, MOTUS C-9), or with
+ * `progress={false}` a numbered list of sections that each hold content (HAR-1628).
+ */
+declare function Steps({ orientation, progress, headingLevel, label, stateLabels, className, children, ...props }: StepsProps): react.JSX.Element;
+declare function Step({ title, description, state, marker, href, renderLink, onSelect, children, index, last, stateLabels, progress, headingLevel, className, ...props }: StepProps): react.JSX.Element;
 
 interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'content'> {
     /** Tooltip text. Pass this or `content`. */
@@ -2196,6 +3677,14 @@ interface SegmentedProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'
     value?: string;
     /** Fires with the option's value when a different option is chosen. */
     onChange?: (value: string) => void;
+    /**
+     * How the choice is exposed to assistive technology (HAR-1604).
+     * `'toggle'` (default): `role="group"` of buttons with `aria-pressed`, for a view or filter
+     * toggle bar. `'radio'`: `role="radiogroup"` of `role="radio"` with `aria-checked`, for a
+     * setting with exactly one value (theme, density, language). Name the group with
+     * `aria-label` or `aria-labelledby` in either mode. The keyboard model is the same in both.
+     */
+    selection?: 'toggle' | 'radio';
     children?: ReactNode;
 }
 /**
@@ -2203,16 +3692,22 @@ interface SegmentedProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'
  * (density, audience, view mode …) that reads as one pill with a lifted active
  * segment. Selection state is shared with `<SegmentedOption>` via context, so
  * the caller only wires `value` + `onChange` once.
+ *
+ * Keyboard (HAR-1604): the group is ONE tab stop, on the selected option (the first enabled
+ * one when nothing is selected). Arrow Right/Down and Left/Up move to the next / previous
+ * enabled option and select it, wrapping at the ends; Home and End jump; Left/Right swap in
+ * a right-to-left group. Before 2.32.0 every option was its own tab stop.
  */
-declare function Segmented({ value, onChange, children, className, ...props }: SegmentedProps): react.JSX.Element;
+declare function Segmented({ value, onChange, selection, children, className, onKeyDown, ...props }: SegmentedProps): react.JSX.Element;
 interface SegmentedOptionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'onChange'> {
     value: string;
     children?: ReactNode;
 }
 /**
  * One option in a `<Segmented>`. Active state is derived from the parent's
- * `value`; the pressed segment lifts to the surface via
- * `.uix-segmented__option[aria-pressed="true"]`.
+ * `value`; the selected segment lifts to the surface via
+ * `.uix-segmented__option[aria-pressed="true"]` (or `[aria-checked="true"]` in a
+ * `selection="radio"` group).
  */
 declare function SegmentedOption({ value, children, className, onClick, ...props }: SegmentedOptionProps): react.JSX.Element;
 
@@ -2425,9 +3920,13 @@ interface ProseProps extends HTMLAttributes<HTMLDivElement> {
  * release notes). Apply to a block of rendered HTML/markdown.
  */
 declare function Prose({ children, className, ...props }: ProseProps): react.JSX.Element;
-type NoteTone = 'info' | 'success' | 'warning' | 'danger';
+type NoteTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
 interface NoteProps extends HTMLAttributes<HTMLDivElement> {
-    tone?: NoteTone;
+    /**
+     * `'neutral'` and `undefined` are both the default look. `undefined` is spelled out in the type
+     * so `tone={maybeTone}` also compiles under `exactOptionalPropertyTypes` (HAR-1614).
+     */
+    tone?: NoteTone | undefined;
     icon?: ReactNode;
     children?: ReactNode;
 }
@@ -2442,7 +3941,8 @@ interface PopoverProps extends HTMLAttributes<HTMLDivElement> {
     popover?: 'auto' | 'manual';
     /**
      * Element (or ref) to anchor against. When set, the popover is placed with
-     * cross-browser JS positioning — flip when it won't fit, shift to stay on-screen.
+     * cross-browser JS positioning — flip when it won't fit, shift to stay on-screen. A popover
+     * that fits neither above nor below slides over its anchor rather than leave the viewport.
      * Where the browser supports CSS anchor positioning, the placement is written as an
      * offset from the anchor, so it stays attached while the page scrolls; elsewhere it
      * follows scroll from JS. The native Popover API still provides the top layer (so it
@@ -2462,6 +3962,24 @@ interface PopoverProps extends HTMLAttributes<HTMLDivElement> {
     closeWhenAnchorHidden?: boolean;
     /** Called when `closeWhenAnchorHidden` is about to close the popover. */
     onAnchorHidden?: () => void;
+    /**
+     * Cap the popover's height to the viewport (minus 8 px at each edge) and scroll inside it,
+     * for content that can be taller than a phone screen. Needs `anchor`. Default `false`.
+     */
+    capHeight?: boolean;
+    /**
+     * Open while the pointer is over the `anchor` or the anchor has keyboard focus, and close
+     * when both have left the anchor and the popover — a hover card (HAR-1614). The pointer can
+     * travel from the anchor into the popover, and focus can move into it, without closing it;
+     * Escape closes it. Touch does not hover: open it from the anchor's own click there.
+     * `true` waits 300 ms before opening and 150 ms before closing; pass the delays to change
+     * them. Needs `anchor`; `popover` then defaults to `"manual"`, so a hover card does not
+     * dismiss a menu or dialog that is open.
+     */
+    openOnHover?: boolean | {
+        openDelay?: number;
+        closeDelay?: number;
+    };
     children?: ReactNode;
 }
 /**
@@ -2469,15 +3987,20 @@ interface PopoverProps extends HTMLAttributes<HTMLDivElement> {
  * things like a filter popover, menu, or rich select by putting controls inside.
  * Pass `anchor` to get collision-aware, cross-browser placement (UIX-FIX-02).
  */
-declare function Popover({ popover, anchor, placement, offset, closeWhenAnchorHidden, onAnchorHidden, className, children, ...props }: PopoverProps): react.JSX.Element;
+declare function Popover({ popover: popoverProp, anchor, placement, offset, closeWhenAnchorHidden, onAnchorHidden, capHeight, openOnHover, className, children, ...props }: PopoverProps): react.JSX.Element;
 
+/** `id` and `data-*` for the item's own element (HAR-1629): a stable hook for tests, journeys and analytics. */
+interface MenuItemAttributes {
+    id?: string;
+    [dataAttribute: `data-${string}`]: string | number | boolean | undefined;
+}
 interface MenuProps {
     /**
      * The menu button, usually a `Button`. It receives `aria-haspopup="menu"`,
      * `aria-expanded`, `aria-controls` and the open/keyboard handlers.
      */
     trigger: ReactElement;
-    /** `MenuItem`, `MenuGroup` and `MenuSeparator`. */
+    /** `MenuItem`, `MenuItemRadio`, `MenuItemCheckbox`, `MenuRadioGroup`, `MenuGroup` and `MenuSeparator`. */
     children?: ReactNode;
     /** Controlled open state; pair with `onOpenChange`. */
     open?: boolean;
@@ -2491,10 +4014,11 @@ interface MenuProps {
 /**
  * A menu button with an APG menu (HAR-1359; TENSOR C1, MOTUS B-A14): ↓/↑ move, Home/End,
  * type-to-find, Enter/Space activate, Esc and Tab close, focus returns to the trigger.
- * The surface is the kit `Popover`, so it escapes clipping containers.
+ * The surface is the kit `Popover`, so it escapes clipping containers; a menu taller than
+ * the viewport is capped to it and scrolls (HAR-1613).
  */
 declare function Menu({ trigger, children, open: controlledOpen, defaultOpen, onOpenChange, label, placement, className }: MenuProps): react.JSX.Element;
-interface MenuItemProps {
+interface MenuItemProps extends MenuItemAttributes {
     children?: ReactNode;
     /** Runs on click, Enter or Space; the menu then closes and focus returns to the trigger. */
     onSelect?: () => void;
@@ -2508,7 +4032,49 @@ interface MenuItemProps {
     disabled?: boolean;
     className?: string;
 }
-declare function MenuItem({ children, onSelect, href, renderLink, icon, shortcut, tone, disabled, className }: MenuItemProps): react.JSX.Element;
+declare function MenuItem({ children, onSelect, href, renderLink, icon, shortcut, tone, disabled, className, ...rest }: MenuItemProps): react.JSX.Element;
+interface MenuRadioGroupProps {
+    /** The `value` of the checked `MenuItemRadio`. */
+    value?: string;
+    onValueChange?: (value: string) => void;
+    /** Visible group heading; it also names the group. */
+    label?: ReactNode;
+    /** Names the group when there is no visible `label`. */
+    'aria-label'?: string;
+    children?: ReactNode;
+}
+/** One choice out of several inside a `Menu`: wraps `MenuItemRadio` rows and holds their value (HAR-1629). */
+declare function MenuRadioGroup({ value, onValueChange, label, 'aria-label': ariaLabel, children }: MenuRadioGroupProps): react.JSX.Element;
+interface MenuItemRadioProps extends MenuItemAttributes {
+    /** Checked when it equals the surrounding `MenuRadioGroup`'s `value`. */
+    value: string;
+    /** For a radio item used without a `MenuRadioGroup`. */
+    checked?: boolean;
+    /** Runs when the item is chosen, after the group's `onValueChange`. */
+    onSelect?: () => void;
+    /** Close the menu after a click or Enter. Default `true`. Space never closes it. */
+    closeOnSelect?: boolean;
+    children?: ReactNode;
+    icon?: ReactNode;
+    shortcut?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+/** A `role="menuitemradio"` row with `aria-checked` and a check mark for the current choice. */
+declare function MenuItemRadio({ value, checked, onSelect, closeOnSelect, ...rest }: MenuItemRadioProps): react.JSX.Element;
+interface MenuItemCheckboxProps extends MenuItemAttributes {
+    checked: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    /** Close the menu after a click or Enter. Default `false`: several boxes are usually ticked in a row. */
+    closeOnSelect?: boolean;
+    children?: ReactNode;
+    icon?: ReactNode;
+    shortcut?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+/** A `role="menuitemcheckbox"` row with `aria-checked`; the menu stays open while boxes are ticked. */
+declare function MenuItemCheckbox({ checked, onCheckedChange, closeOnSelect, ...rest }: MenuItemCheckboxProps): react.JSX.Element;
 interface MenuGroupProps {
     label: ReactNode;
     children?: ReactNode;
@@ -2903,128 +4469,6 @@ interface StatusRowProps extends HTMLAttributes<HTMLDivElement> {
 /** Status row — indicator + name + trailing meta (`.uix-status-row`). */
 declare function StatusRow({ indicator, name, meta, className, ...props }: StatusRowProps): react.JSX.Element;
 
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-
-interface RuleCondition {
-    id: string;
-    field: string;
-    operator: string;
-    value?: JsonValue;
-}
-interface RuleGroup {
-    id: string;
-    combinator: 'and' | 'or';
-    conditions: Array<RuleCondition | RuleGroup>;
-}
-interface RuleAction {
-    id: string;
-    type: string;
-    parameters: Record<string, JsonValue>;
-}
-interface RuleDefinition {
-    when: RuleGroup;
-    then: RuleAction[];
-}
-interface RuleValidationIssue {
-    path: string;
-    message: string;
-}
-declare function isRuleGroup(node: RuleCondition | RuleGroup): node is RuleGroup;
-declare function ruleDepth(group: RuleGroup): number;
-declare function findRuleNodeDepth(group: RuleGroup, id: string, depth?: number): number | undefined;
-declare function mapRuleGroup(group: RuleGroup, id: string, update: (node: RuleCondition | RuleGroup) => RuleCondition | RuleGroup): RuleGroup;
-declare function appendRuleNode(group: RuleGroup, parentId: string, node: RuleCondition | RuleGroup, maxDepth?: number): RuleGroup;
-declare function removeRuleNode(group: RuleGroup, id: string): RuleGroup;
-declare function moveRuleNode(group: RuleGroup, id: string, direction: -1 | 1): RuleGroup;
-declare function validateRuleDefinition(value: RuleDefinition, maxDepth?: number): RuleValidationIssue[];
-declare function summarizeRule(value: RuleDefinition, labels?: {
-    fields?: Record<string, string>;
-    operators?: Record<string, string>;
-    actions?: Record<string, string>;
-}): string;
-
-interface RuleValueEditorProps {
-    condition: RuleCondition;
-    onChange: (value: JsonValue | undefined) => void;
-    disabled?: boolean;
-}
-interface RuleFieldDefinition {
-    id: string;
-    label: string;
-    description?: string;
-    operators?: string[];
-    renderValueEditor?: (props: RuleValueEditorProps) => ReactNode;
-}
-interface RuleOperatorDefinition {
-    id: string;
-    label: string;
-    requiresValue?: boolean;
-}
-interface RuleActionDefinition {
-    id: string;
-    label: string;
-    renderParameters?: (action: RuleAction, onChange: (parameters: Record<string, JsonValue>) => void, disabled: boolean) => ReactNode;
-}
-/**
- * Every word the rule builder renders (TENSOR RX-125, UIX-12). `{item}` is one of
- * `itemGroup` / `itemCondition` / `itemAction`; `{field}` a field label; `{count}` a number.
- */
-interface RuleBuilderLabels {
-    region: string;
-    summary: string;
-    when: string;
-    group: string;
-    match: string;
-    all: string;
-    any: string;
-    field: string;
-    operator: string;
-    valueFor: string;
-    itemGroup: string;
-    itemCondition: string;
-    itemAction: string;
-    moveUp: string;
-    moveUpNamed: string;
-    moveDown: string;
-    moveDownNamed: string;
-    remove: string;
-    removeNamed: string;
-    then: string;
-    actionType: string;
-    valid: string;
-    issuesOne: string;
-    issuesMany: string;
-    summaryIssuesOne: string;
-    summaryIssuesMany: string;
-    addCondition: string;
-    addGroup: string;
-    addAction: string;
-}
-declare const DEFAULT_RULE_BUILDER_LABELS: RuleBuilderLabels;
-interface RuleBuilderProps {
-    value: RuleDefinition;
-    onChange: (value: RuleDefinition) => void;
-    fields: RuleFieldDefinition[];
-    operators: RuleOperatorDefinition[];
-    actions: RuleActionDefinition[];
-    maxDepth?: number;
-    readOnly?: boolean;
-    validate?: (value: RuleDefinition) => RuleValidationIssue[];
-    className?: string;
-    /** @deprecated use `labels.addCondition` */
-    addConditionLabel?: string;
-    /** @deprecated use `labels.addGroup` */
-    addGroupLabel?: string;
-    /** @deprecated use `labels.addAction` */
-    addActionLabel?: string;
-    labels?: Partial<RuleBuilderLabels>;
-}
-/** Declarative controlled when-conditions-to-actions editor with bounded nesting. */
-declare function RuleBuilder({ value, onChange, fields, operators, actions, maxDepth, readOnly, validate, className, addConditionLabel, addGroupLabel, addActionLabel, labels: labelOverrides, }: RuleBuilderProps): react.JSX.Element;
-
 interface BuilderCanvasItem {
     id: string;
     type: string;
@@ -3645,4 +5089,4 @@ declare function hsvToHex(value: HsvColor): string;
 declare function contrastRatio(background: string, foreground: string): number | undefined;
 declare function meetsContrast(background: string, foreground: string, minimum?: number): boolean;
 
-export { type AccessStateProps, Alert, type AlertProps, type AlertTone, AppShell, type AppShellProps, type AppliedBrandProfileSnapshot, type AsyncOperationState, AsyncOperationStatus, type AsyncOperationStatusProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type BoundedRelationshipGraph, type BrandProfile, BrandProfileEditor, type BrandProfileEditorLabels, type BrandProfileEditorProps, type BrandProfileLogo, type BrandProfileTypography, BrandProfiles, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, BuilderCanvas, type BuilderCanvasItem, type BuilderCanvasLabels, type BuilderCanvasProps, type BuilderPaletteItem, BulkBar, type BulkBarProps, Button, ButtonGroup, type ButtonGroupProps, ButtonLink, type ButtonLinkProps, type ButtonProps, type ButtonSize, type ButtonVariant, type CalendarDay, type CalendarWeekday, Card, CardLink, type CardLinkProps, type CardProps, CellStrong, CellSub, Checkbox, type CheckboxProps, Chip, ChipGroup, type ChipGroupProps, type ChipProps, CollapsibleSection, type CollapsibleSectionProps, ColorPicker, type ColorPickerLabels, type ColorPickerProps, type ColumnFilter, Combobox, type ComboboxOption, type ComboboxProps, CommandGroup, type CommandGroupProps, CommandItem, type CommandItemProps, CommandPalette, type CommandPaletteProps, Comment, type CommentProps, Comments, type CommentsProps, Composer, ComposerBar, type ComposerBarProps, type ComposerProps, ConfirmDialog, type ConfirmDialogProps, ContentList, ContentListItem, type ContentListItemProps, type ContentListProps, CopyButton, type CopyButtonProps, DAY, DEFAULT_BRAND_PROFILE_EDITOR_LABELS, DEFAULT_BUILDER_CANVAS_LABELS, DEFAULT_COLOR_PICKER_LABELS, DEFAULT_DATE_RANGE_PICKER_LABELS, DEFAULT_DIFF_VIEWER_LABELS, DEFAULT_MATCH_REVIEW_LABELS, DEFAULT_PAGINATION_LABELS, DEFAULT_RELATIONSHIP_GRAPH_LABELS, DEFAULT_RULE_BUILDER_LABELS, DEFAULT_SAVE_STATUS_LABELS, DEFAULT_SCHEDULING_CALENDAR_LABELS, DEFAULT_SCHEDULING_TIMELINE_LABELS, DEFAULT_STEP_STATE_LABELS, DateRangePicker, type DateRangePickerLabels, type DateRangePickerProps, type DateRangeValue, DescriptionItem, type DescriptionItemProps, DescriptionList, type DescriptionListItem, type DescriptionListProps, DetailLayout, type DetailLayoutProps, DetailPage, type DetailPageLinkProps, type DetailPageMetric, type DetailPageProps, type DetailPageTab, type DiffEntry, type DiffKind, type DiffResolution, type DiffSummary, DiffViewer, type DiffViewerLabels, type DiffViewerProps, Drawer, type DrawerProps, EmptyState, type EmptyStateProps, ErrorState, type ErrorStateProps, EventRow, type EventRowProps, ExpandToggle, type ExpandToggleProps, FeaturedRundown, FeaturedRundownItem, type FeaturedRundownItemProps, type FeaturedRundownProps, FeaturedStage, type FeaturedStageProps, Field, type FieldProps, type FilterKind, type FilterOp, type FilterOption, FilterPopover, type FilterPopoverProps, FilteredEmptyState, type FlatNode, Flow, FlowNode, type FlowNodeProps, type FlowNodeState, type FlowProps, type FlowVariant, type FoldedText, ForbiddenState, HOUR, Highlighted, type HighlightedProps, type HsvColor, Inbox, InboxDetail, type InboxDetailProps, InboxItem, type InboxItemProps, InboxList, type InboxListProps, type InboxProps, InfoTip, type InfoTipProps, Input, InputGroup, type InputGroupProps, type InputProps, type JsonPrimitive, type JsonValue, Kanban, KanbanCard, type KanbanCardProps, KanbanColumn, type KanbanColumnProps, type KanbanMoveDirection, type KanbanProps, Kbd, KbdCombo, type KbdComboProps, type KbdPlatform, type KbdProps, Label, type LabelProps, type LayeredColumn, type LayeredEdgeClassification, type LayeredEdgeKind, type LayeredItem, type LayeredLayout, type LayeredLayoutOptions, type LayeredNavigationKey, LicensePositionBar, type LicensePositionBarProps, List, ListItem, type ListItemProps, type ListProps, LoadingState, type LoadingStateProps, Mark, type MarkProps, type MatchBulkResult, MatchReview, type MatchReviewAction, type MatchReviewCandidate, type MatchReviewField, type MatchReviewLabels, type MatchReviewProps, Menu, MenuGroup, type MenuGroupProps, MenuItem, type MenuItemProps, type MenuProps, MenuSeparator, Meter, type MeterProps, type MeterTone, MetricInput, type MetricInputProps, Modal, type ModalProps, type NavFavouriteItem, NavFavourites, type NavFavouritesLabels, type NavFavouritesProps, NavGroup, type NavGroupProps, NavItem, type NavItemProps, NewsLead, type NewsLeadProps, NotFoundState, Note, type NoteProps, type NoteTone, NoticeQueue, type NoticeQueueProps, PageHeader, type PageHeaderProps, PageIntro, type PageIntroProps, Pagination, type PaginationLabels, type PaginationProps, Peek, type PeekProps, type PillTone, type PillTreatment, Pipeline, type PipelineProps, PipelineStage, type PipelineStageProps, type PipelineStageState, type PlacedSpan, Placement, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, type PositionedRelationshipNode, type Primitive, Progress, type ProgressProps, PromptDialog, type PromptDialogProps, Prose, type ProseProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, type RelatedLinkItem, RelatedLinks, type RelatedLinksProps, RelationshipGraph, type RelationshipGraphArrow, type RelationshipGraphCluster, type RelationshipGraphEdge, type RelationshipGraphLabels, type RelationshipGraphLegendItem, type RelationshipGraphNode, type RelationshipGraphProps, RelativeTime, type RelativeTimeFormatContext, type RelativeTimeProps, type RelativeTimeUnit, type RelativeTimeValue, ResourceGrid, type ResourceGridProps, type RgbColor, type RoutedEdge, type Row, RowAction, type RowActionProps, RowActions, type RowActionsProps, type RuleAction, type RuleActionDefinition, RuleBuilder, type RuleBuilderLabels, type RuleBuilderProps, type RuleCondition, type RuleDefinition, type RuleFieldDefinition, type RuleGroup, type RuleOperatorDefinition, type RuleValidationIssue, type RuleValueEditorProps, SaveStatus, type SaveStatusLabels, type SaveStatusProps, type SaveStatusState, type SavedViewItem, SavedViewMenu, type SavedViewMenuProps, type SavedViewSection, SchedulingCalendar, type SchedulingCalendarEntry, type SchedulingCalendarLabels, type SchedulingCalendarOverlay, type SchedulingCalendarProps, type SchedulingCalendarView, type SchedulingDatePart, type SchedulingEntryState, type SchedulingOverlayKind, SchedulingTimeline, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps, type SearchSegment, SearchSuggest, type SearchSuggestAction, type SearchSuggestOption, type SearchSuggestProps, SectionHead, type SectionHeadProps, type Segment, Segmented, SegmentedOption, type SegmentedOptionProps, type SegmentedProps, Select, type SelectAllState, type SelectProps, type ShellNav, Sidebar, type SidebarProps, SidebarSection, type SidebarSectionProps, Skeleton, type SkeletonProps, type SortDir, type SortDirection, type SortKey, Spinner, type SpinnerProps, StarButton, type StarButtonProps, Stat, StatLine, type StatLineItem, type StatLineProps, type StatProps, type StatTrend, type StateVariant, StatusPill, type StatusPillProps, StatusRow, type StatusRowProps, Step, type StepProps, type StepState, type StepStateLabels, Steps, type StepsProps, SubNavItem, type SubNavItemProps, Switch, type SwitchProps, TOAST_LEAVE_MS, Tab, TabPanel, type TabPanelProps, type TabProps, Table, type TableDensity, type TableProps, TableWrap, type TableWrapProps, Tabs, type TabsProps, Td, type TdProps, Textarea, type TextareaProps, Th, type ThProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, type TimelineRange, type TimelineScale, type TimelineSpan, type TimelineTick, Toast, type ToastAction, type ToastApi, type ToastDismissReason, type ToastKind, type ToastOptions, type ToastPromiseMessages, type ToastProps, type ToastRecord, type ToastStore, type ToastTone, Toaster, type ToasterProps, ToggleRow, type ToggleRowProps, Tooltip, type TooltipProps, Tr, type TrProps, Tree, type TreeLike, type TreeNavAction, type TreeNodeData, type TreeNodeProps, type TreeProps, type UixLabels, UixLabelsProvider, type UixLabelsProviderProps, type UixLinkProps, type UixRenderLink, type UndoableToastOptions, type UseAnchoredPositionOptions, type UseTableOptions, type UseTableResult, type UseVirtualRowsOptions, type UseVirtualRowsResult, UserChip, type UserChipProps, ViewMenu, type ViewMenuColumn, type ViewMenuColumnLabels, type ViewMenuProps, type ViewState, type VirtualWindow, type ZonedDateSpan, addCalendarDays, addCalendarMonths, appendRuleNode, applyBrandProfile, applyFilters, boundRelationshipGraph, buildMonthGrid, buildThreeWayDiff, clampMetricValue, clampWidth, classifyLayeredEdges, clusterIdFor, contrastRatio, createToastApi, createToastStore, cx, defaultTimelineStep, enumerateDateSpan, filterComboboxOptions, findRuleNodeDepth, flattenTree, foldForSearch, hexToRgb, highlightSegments, hsvToHex, hsvToRgb, isDateInRange, isDateUnavailable, isRuleGroup, layeredNeighbor, layoutLane, layoutLayeredGraph, layoutRelationshipGraph, mapRuleGroup, matchFilter, meetsContrast, mergePinned, moveRuleNode, multiSort, nextSortDir, normalizeHex, parseDateValue, parseMetricValue, parseView, pixelsToMs, placeSpan, relationshipNeighbors, relativeTimeValue, removeRuleNode, renderPlainLink, reorder, restoreBrandProfile, rgbToHex, rgbToHsv, ruleDepth, searchRows, searchSegments, selectAllState, selectRangeDate, serializeView, shiftSpan, shouldVirtualize, snapToStep, startOfMonth, stepMetricValue, summarizeDiff, summarizeRule, timelineTicks, toDateKey, toast, toggleId, togglePage, toggleSort, traverseRelationshipNode, treeNav, useAnchoredPosition, useDialog, useTable, useUixLabels, useVirtualRows, validateRuleDefinition, virtualWindow, wrapEdgeLabel, zonedDateKey, zonedDateSpan };
+export { type AccessStateProps, Alert, type AlertProps, type AlertTone, AppShell, type AppShellProps, type AppliedBrandProfileSnapshot, type AsyncOperationState, AsyncOperationStatus, type AsyncOperationStatusProps, Attachment, type AttachmentLabels, AttachmentList, type AttachmentListProps, type AttachmentProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type BoundedRelationshipGraph, type BrandProfile, BrandProfileEditor, type BrandProfileEditorLabels, type BrandProfileEditorProps, type BrandProfileLogo, type BrandProfileTypography, BrandProfiles, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, BuilderCanvas, type BuilderCanvasItem, type BuilderCanvasLabels, type BuilderCanvasProps, type BuilderPaletteItem, BulkBar, type BulkBarProps, Button, ButtonGroup, type ButtonGroupProps, ButtonLink, type ButtonLinkProps, type ButtonProps, type ButtonSize, type ButtonVariant, type CalendarDay, type CalendarWeekday, Card, CardLink, type CardLinkProps, type CardProps, CellStrong, CellSub, Checkbox, type CheckboxProps, Chip, ChipGroup, type ChipGroupProps, type ChipProps, CollapsibleSection, type CollapsibleSectionProps, ColorPicker, type ColorPickerLabels, type ColorPickerProps, type ColumnFilter, Combobox, type ComboboxOption, type ComboboxProps, CommandGroup, type CommandGroupProps, CommandItem, type CommandItemProps, CommandPalette, type CommandPaletteProps, Comment, type CommentProps, Comments, type CommentsProps, Composer, ComposerBar, type ComposerBarProps, type ComposerProps, ConfirmDialog, type ConfirmDialogProps, ContentList, ContentListItem, type ContentListItemProps, type ContentListProps, CopyButton, type CopyButtonProps, DAY, DEFAULT_ATTACHMENT_LABELS, DEFAULT_BRAND_PROFILE_EDITOR_LABELS, DEFAULT_BUILDER_CANVAS_LABELS, DEFAULT_COLOR_PICKER_LABELS, DEFAULT_DATE_RANGE_PICKER_LABELS, DEFAULT_DIFF_VIEWER_LABELS, DEFAULT_ENTITY_PICKER_LABELS, DEFAULT_FILE_UPLOAD_LABELS, DEFAULT_FILTER_EDITOR_LABELS, DEFAULT_FILTER_SUMMARY_LABELS, DEFAULT_LIGHTBOX_LABELS, DEFAULT_MATCH_REVIEW_LABELS, DEFAULT_PAGINATION_LABELS, DEFAULT_RELATIONSHIP_GRAPH_LABELS, DEFAULT_RULE_BUILDER_LABELS, DEFAULT_RULE_SUMMARY_WORDS, DEFAULT_RULE_VALIDATION_MESSAGES, DEFAULT_SAVE_STATUS_LABELS, DEFAULT_SCHEDULING_CALENDAR_LABELS, DEFAULT_SCHEDULING_TIMELINE_LABELS, DEFAULT_STEP_STATE_LABELS, DEFAULT_TEXT_DIFF_LABELS, DashboardGrid, type DashboardGridBreakpoint, type DashboardGridColumnCount, type DashboardGridColumns, type DashboardGridGap, DashboardGridItem, type DashboardGridItemProps, type DashboardGridProps, type DashboardGridSpan, DateRangePicker, type DateRangePickerLabels, type DateRangePickerProps, type DateRangeValue, DescriptionItem, type DescriptionItemProps, DescriptionList, type DescriptionListItem, type DescriptionListProps, DetailLayout, type DetailLayoutProps, DetailPage, type DetailPageLinkProps, type DetailPageMetric, type DetailPageProps, type DetailPageTab, type DiffEntry, type DiffKind, type DiffResolution, type DiffSummary, DiffViewer, type DiffViewerLabels, type DiffViewerProps, Drawer, type DrawerProps, EmptyState, type EmptyStateProps, EntityPicker, type EntityPickerLabels, type EntityPickerProps, ErrorState, type ErrorStateProps, EventRow, type EventRowProps, ExpandToggle, type ExpandToggleProps, FeaturedRundown, FeaturedRundownItem, type FeaturedRundownItemProps, type FeaturedRundownProps, FeaturedStage, type FeaturedStageProps, Field, type FieldProps, type FileRejection, type FileRejectionReason, type FileSizeFormatter, type FileSizeOptions, FileUpload, type FileUploadItem, type FileUploadLabels, type FileUploadProps, type FileUploadStatus, type FilterChoice, FilterEditor, type FilterEditorLabels, type FilterEditorProps, type FilterField, type FilterKind, type FilterOp, type FilterOption, FilterPopover, type FilterPopoverProps, type FilterPreset, type FilterSummaryLabels, type FilterValue, type FilterValueKind, FilteredEmptyState, type FlatNode, Flow, FlowNode, type FlowNodeProps, type FlowNodeState, type FlowProps, type FlowVariant, type FoldedText, ForbiddenState, HOUR, Heartbeat, type HeartbeatProps, type HeartbeatState, Highlighted, type HighlightedProps, type HsvColor, Inbox, InboxDetail, type InboxDetailProps, InboxItem, type InboxItemProps, InboxList, type InboxListProps, type InboxProps, InfoTip, type InfoTipProps, Input, InputGroup, type InputGroupProps, type InputProps, type JsonPrimitive, type JsonValue, Kanban, KanbanCard, type KanbanCardProps, KanbanColumn, type KanbanColumnProps, type KanbanMoveDirection, type KanbanProps, Kbd, KbdCombo, type KbdComboProps, type KbdPlatform, type KbdProps, Label, type LabelProps, type LaneCluster, type LaneInterval, type LanePlacement, type LayeredColumn, type LayeredEdgeClassification, type LayeredEdgeKind, type LayeredItem, type LayeredLayout, type LayeredLayoutOptions, type LayeredNavigationKey, type LayoutMonthSpansOptions, LicensePositionBar, type LicensePositionBarProps, Lightbox, type LightboxItem, type LightboxLabels, type LightboxProps, List, ListItem, type ListItemProps, type ListProps, LiveIndicator, type LiveIndicatorProps, LoadingState, type LoadingStateProps, Mark, type MarkProps, type MatchBulkResult, MatchReview, type MatchReviewAction, type MatchReviewCandidate, type MatchReviewField, type MatchReviewLabels, type MatchReviewProps, Menu, MenuGroup, type MenuGroupProps, MenuItem, type MenuItemAttributes, MenuItemCheckbox, type MenuItemCheckboxProps, type MenuItemProps, MenuItemRadio, type MenuItemRadioProps, type MenuProps, MenuRadioGroup, type MenuRadioGroupProps, MenuSeparator, Meter, type MeterProps, type MeterTone, MetricInput, type MetricInputProps, Modal, type ModalProps, type MonthSpanGroup, type MonthSpanInput, type MonthSpanLayout, NUMBER_FILTER_OPERATORS, type NavFavouriteItem, NavFavourites, type NavFavouritesLabels, type NavFavouritesProps, NavGroup, type NavGroupProps, NavItem, type NavItemProps, NewsLead, type NewsLeadProps, NotFoundState, Note, type NoteProps, type NoteTone, NoticeQueue, type NoticeQueueProps, type NumberFilterOperator, type PackLanesOptions, type PackedLanes, PageHeader, type PageHeaderProps, PageIntro, type PageIntroProps, Pagination, type PaginationLabels, type PaginationProps, Peek, type PeekProps, type PillSize, type PillTone, type PillTreatment, Pipeline, type PipelineProps, PipelineStage, type PipelineStageProps, type PipelineStageState, type PlacedMonthSpan, type PlacedSpan, Placement, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, type PositionedRelationshipNode, type Primitive, Progress, type ProgressProps, PromptDialog, type PromptDialogProps, Prose, type ProseProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, type RelatedLinkItem, RelatedLinks, type RelatedLinksProps, RelationshipGraph, type RelationshipGraphArrow, type RelationshipGraphCluster, type RelationshipGraphEdge, type RelationshipGraphLabels, type RelationshipGraphLegendItem, type RelationshipGraphNode, type RelationshipGraphProps, RelativeTime, type RelativeTimeFormatContext, type RelativeTimeProps, type RelativeTimeUnit, type RelativeTimeValue, ResourceGrid, type ResourceGridProps, type RgbColor, type RoutedEdge, type Row, RowAction, type RowActionProps, RowActions, type RowActionsProps, type RuleAction, type RuleActionDefinition, RuleBuilder, type RuleBuilderLabels, type RuleBuilderProps, type RuleCheck, type RuleCondition, type RuleDefinition, type RuleFieldDefinition, type RuleGroup, type RuleOperatorDefinition, type RuleSummaryWords, type RuleValidationIssue, type RuleValidationOptions, type RuleValueEditorProps, SaveStatus, type SaveStatusLabels, type SaveStatusProps, type SaveStatusState, type SavedViewItem, SavedViewMenu, type SavedViewMenuProps, type SavedViewSection, type SchedulingBand, SchedulingCalendar, type SchedulingCalendarDay, type SchedulingCalendarEntry, type SchedulingCalendarLabels, type SchedulingCalendarOverlay, type SchedulingCalendarProps, type SchedulingCalendarView, type SchedulingDatePart, type SchedulingEntryState, type SchedulingLegendItem, type SchedulingMarker, type SchedulingMarkerEmphasis, type SchedulingOverlayKind, type SchedulingOverlayPattern, type SchedulingStatus, SchedulingTimeline, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps, type SearchSegment, SearchSuggest, type SearchSuggestAction, type SearchSuggestOption, type SearchSuggestProps, SectionHead, type SectionHeadProps, type Segment, Segmented, SegmentedOption, type SegmentedOptionProps, type SegmentedProps, Select, type SelectAllState, type SelectGroup, type SelectLabels, type SelectOption, type SelectProps, type ShellNav, Sidebar, type SidebarProps, SidebarSection, type SidebarSectionProps, Skeleton, type SkeletonProps, type SortDir, type SortDirection, type SortKey, Spinner, type SpinnerProps, StarButton, type StarButtonProps, Stat, StatLine, type StatLineItem, type StatLineProps, type StatProps, type StatTrend, type StateVariant, StatusPill, type StatusPillProps, StatusRow, type StatusRowProps, Step, type StepProps, type StepState, type StepStateLabels, Steps, type StepsProps, SubNavItem, type SubNavItemProps, type SummarizeFilterOptions, Switch, type SwitchProps, TEXT_FILTER_OPERATORS, TOAST_LEAVE_MS, Tab, TabPanel, type TabPanelProps, type TabProps, Table, type TableDensity, type TableProps, TableWrap, type TableWrapProps, Tabs, type TabsProps, Td, type TdProps, TextDiff, type TextDiffGranularity, type TextDiffLabels, type TextDiffLine, type TextDiffOp, type TextDiffOptions, type TextDiffProps, type TextDiffResult, type TextDiffRow, type TextDiffSegment, type TextFilterOperator, Textarea, type TextareaProps, Th, type ThProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, type TimelineRange, type TimelineScale, type TimelineSpan, type TimelineTick, Toast, type ToastAction, type ToastApi, type ToastDismissReason, type ToastKind, type ToastOptions, type ToastPromiseMessages, type ToastProps, type ToastRecord, type ToastStore, type ToastTone, Toaster, type ToasterProps, ToggleRow, type ToggleRowProps, Tooltip, type TooltipProps, Tr, type TrProps, Tree, type TreeLike, type TreeNavAction, type TreeNodeData, type TreeNodeProps, type TreeProps, type UixLabels, UixLabelsProvider, type UixLabelsProviderProps, type UixLinkProps, type UixRenderLink, type UndoableToastOptions, type UseAnchoredPositionOptions, type UseTableOptions, type UseTableResult, type UseVirtualRowsOptions, type UseVirtualRowsResult, UserChip, type UserChipProps, ViewMenu, type ViewMenuColumn, type ViewMenuColumnLabels, type ViewMenuProps, type ViewState, type VirtualWindow, type ZonedDateSpan, type ZonedDayBounds, type ZonedDayShift, type ZonedDaySpan, type ZonedHourSlot, addCalendarDays, addCalendarMonths, addZonedDays, appendRuleNode, applyBrandProfile, applyFilters, boundRelationshipGraph, buildMonthGrid, buildThreeWayDiff, cachedDateTimeFormat, clampMetricValue, clampWidth, classifyLayeredEdges, clusterIdFor, contrastRatio, createToastApi, createToastStore, cx, dashboardGridClassName, dashboardGridItemClassName, defaultTimelineStep, diffText, diffTokens, emptyFilterValue, enumerateDateKeys, enumerateDateSpan, fileKind, fileMatchesAccept, filterComboboxOptions, findRuleNodeDepth, flattenTree, foldForSearch, formatFileSize, hexToRgb, highlightSegments, hsvToHex, hsvToRgb, isDateInRange, isDateUnavailable, isFilterEmpty, isRuleGroup, itemDaySpan, layeredNeighbor, layoutLane, layoutLayeredGraph, layoutMonthSpans, layoutRelationshipGraph, mapRuleGroup, matchFilter, matchFilterPreset, meetsContrast, mergePinned, moveRuleNode, multiSort, nextSortDir, normalizeHex, packLanes, parseDateValue, parseMetricValue, parseView, partitionFiles, pixelsToMs, placeSpan, rankOverflow, relationshipNeighbors, relativeTimeValue, removeRuleNode, renderPlainLink, reorder, restoreBrandProfile, rgbToHex, rgbToHsv, ruleDepth, schedulingGridDays, searchRows, searchSegments, selectAllState, selectRangeDate, serializeView, setRuleCombinator, shiftSpan, shouldVirtualize, snapToStep, startOfMonth, stepMetricValue, summarizeDiff, summarizeFilter, summarizeRule, textDiffRows, timelineTicks, toDateKey, toast, toggleId, togglePage, toggleSort, tokenizeText, traverseRelationshipNode, treeNav, useAnchoredPosition, useDialog, useTable, useUixLabels, useVirtualRows, validateRuleDefinition, virtualWindow, wrapEdgeLabel, zonedDateKey, zonedDateSpan, zonedDayBounds, zonedDaySpan, zonedHourSlots, zonedTimeOfDay };