@tensor_1/react 2.46.0 → 2.48.0

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import * as react from 'react';
-import { RefObject, AnchorHTMLAttributes, ReactNode, HTMLAttributes, ButtonHTMLAttributes, AriaAttributes, CSSProperties, SelectHTMLAttributes, Ref, SyntheticEvent, InputHTMLAttributes, TextareaHTMLAttributes, MouseEvent, DetailsHTMLAttributes, LiHTMLAttributes, TdHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, ReactElement } from 'react';
+import { RefObject, HTMLAttributes, AnchorHTMLAttributes, ReactNode, ButtonHTMLAttributes, AriaAttributes, CSSProperties, SelectHTMLAttributes, Ref, SyntheticEvent, KeyboardEvent as KeyboardEvent$1, SVGAttributes, InputHTMLAttributes, TdHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TextareaHTMLAttributes, MouseEvent, DetailsHTMLAttributes, LiHTMLAttributes, 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';
 export { C as ChartStatPoint, L as LinearFit, P as PredictionBandPoint, l as linearFit, n as normalQuantile, p as predictionBand, q as quantiles, s as studentTQuantile } from './chart-stats-o4zDhpVm.cjs';
@@ -10,6 +10,11 @@ declare function cx(...args: (string | false | null | undefined | 0)[]): string;
  * `keepOpen` is asked when the browser closed the dialog on its own (Escape or a close request
  * nobody cancelled, a `method="dialog"` form). Returning `true` reopens it instead of calling
  * `onClose`: a form dialog with unsaved input or a save in flight (HAR-2029).
+ *
+ * The dialog opens and closes in a layout effect (HAR-1831). A dialog its caller unmounts while
+ * open (`{open && <ConfirmDialog …/>}`, or a page that navigates away) is closed in the commit,
+ * while it is still in the document, so the browser returns focus to the control that opened it;
+ * a passive cleanup ran after the element was removed, and focus fell to `<body>`.
  */
 declare function useDialog(open: boolean, onClose?: () => void, keepOpen?: () => boolean): React.RefObject<HTMLDialogElement>;
 
@@ -161,8 +166,22 @@ interface UseTableResult<T> {
 declare function useTable<T extends Row>(data: readonly T[], options?: UseTableOptions): UseTableResult<T>;
 
 interface UseVirtualRowsOptions {
-    /** Fixed rendered row height in pixels. */
+    /**
+     * Rendered row height in pixels. With `measureRows` it is the estimate for the first paint,
+     * until the mounted rows have been measured.
+     */
     rowHeight: number;
+    /**
+     * A selector for the mounted data rows inside the container, e.g. `'tbody > tr[data-row]'`
+     * (HAR-1829). With it the hook sizes its spacers and window from the rows' real pitch (their
+     * mean `offsetHeight`) instead of trusting `rowHeight`, which only has to be close: a row's
+     * height comes from CSS and content (kit padding, a second line, density), and a wrong number
+     * gives a short scrollbar and a window that drifts away from the rows on screen. It measures
+     * when windowing starts, when `rowHeight` changes (a density switch) and when the container
+     * resizes, never while scrolling, so the spacers do not move under the reader. Spacer rows
+     * must not match it.
+     */
+    measureRows?: string;
     /** Rows rendered beyond each viewport edge. Default: 6. */
     overscan?: number;
     /**
@@ -190,6 +209,11 @@ interface UseVirtualRowsResult<T> {
     padBottom: number;
     totalHeight: number;
     virtualized: boolean;
+    /**
+     * The row height in use: the measured pitch with `measureRows`, else the `rowHeight` option.
+     * Scroll a keyboard-focused row into view with it (`index * rowHeight`).
+     */
+    rowHeight: number;
 }
 /**
  * Owns scroll/resize observation and exposes the small visible row window.
@@ -197,7 +221,7 @@ interface UseVirtualRowsResult<T> {
  * 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, estimatedViewportHeight, enabled }: UseVirtualRowsOptions): UseVirtualRowsResult<T>;
+declare function useVirtualRows<T>(rows: readonly T[], { rowHeight: estimate, overscan, threshold, estimatedViewportHeight, enabled, measureRows }: UseVirtualRowsOptions): UseVirtualRowsResult<T>;
 
 interface UseAnchoredPositionOptions {
     /** Reposition while true, and (re)attach scroll/resize listeners. */
@@ -245,11 +269,259 @@ interface UseAnchoredPositionOptions {
  */
 declare function useAnchoredPosition(anchor: RefObject<HTMLElement | null> | HTMLElement | null | undefined, floatingRef: RefObject<HTMLElement | null>, { open, placement, offset, padding, shiftMainAxis, capHeight, onAnchorHidden }: UseAnchoredPositionOptions): () => void;
 
-/** Non-hook read for event handlers and effects. `false` where there is no `matchMedia` (SSR, tests). */
+/**
+ * Non-hook read for event handlers and effects: the OS setting, or the in-app preference
+ * `<html data-motion="reduce">` (HAR-1372). `false` where there is no `matchMedia` (SSR, tests).
+ */
 declare function prefersReducedMotion(): boolean;
 /** True while the user asks for reduced motion; re-renders when the setting changes. `false` on the server. */
 declare function useReducedMotion(): boolean;
 
+type ThemePreference = 'light' | 'dark' | 'system';
+type ContrastPreference = 'standard' | 'more' | 'system';
+type TextScalePreference = 'sm' | 'md' | 'lg' | 'xl';
+type MotionPreference = 'system' | 'reduce';
+type DensityPreference = 'compact' | 'standard' | 'comfortable';
+interface DisplayPreferenceValues {
+    theme: ThemePreference;
+    contrast: ContrastPreference;
+    textScale: TextScalePreference;
+    motion: MotionPreference;
+    density: DensityPreference;
+}
+/** What the system says, for the `system` choices. */
+interface SystemDisplayPreferences {
+    dark: boolean;
+    moreContrast: boolean;
+}
+/** The attributes written on <html>; `undefined` means the attribute is removed. */
+interface DisplayAttributes {
+    'data-theme': 'light' | 'dark';
+    'data-contrast'?: 'more';
+    'data-text-scale'?: 'sm' | 'lg' | 'xl';
+    'data-motion'?: 'reduce';
+    'data-density'?: 'compact' | 'comfortable';
+}
+declare const DEFAULT_DISPLAY_PREFERENCES: DisplayPreferenceValues;
+/** The default `localStorage` key. */
+declare const DISPLAY_PREFERENCES_STORAGE_KEY = "uix-display-preferences";
+declare const DISPLAY_PREFERENCE_OPTIONS: {
+    readonly theme: readonly ["light", "dark", "system"];
+    readonly contrast: readonly ["standard", "more", "system"];
+    readonly textScale: readonly ["sm", "md", "lg", "xl"];
+    readonly motion: readonly ["system", "reduce"];
+    readonly density: readonly ["compact", "standard", "comfortable"];
+};
+/** Read stored preferences; anything missing or unknown falls back to `defaults`. */
+declare function parseDisplayPreferences(raw: string | null | undefined, defaults?: DisplayPreferenceValues): DisplayPreferenceValues;
+/** The <html> attributes for a set of preferences, resolving `system` against the system. */
+declare function resolveDisplayAttributes(prefs: DisplayPreferenceValues, system: SystemDisplayPreferences): DisplayAttributes;
+/** Write (or remove) the attributes on an element, normally `document.documentElement`. */
+declare function applyDisplayAttributes(root: Element, attributes: DisplayAttributes): void;
+/** The system's answers from `matchMedia`; all false where there is none (SSR, tests). */
+declare function readSystemDisplayPreferences(): SystemDisplayPreferences;
+/**
+ * An inline script for the document head that applies the stored preferences before the first
+ * paint, so a dark or large-text page never flashes light or small (HAR-1372). Self-contained ES5;
+ * it never throws. Put it in a `<script>` before the stylesheets:
+ *   <script dangerouslySetInnerHTML={{ __html: displayPreferencesScript() }} />
+ * It mirrors parseDisplayPreferences + resolveDisplayAttributes (tested to agree).
+ */
+declare function displayPreferencesScript(storageKey?: string, defaults?: DisplayPreferenceValues): string;
+
+interface UseDisplayPreferencesOptions {
+    /** `localStorage` key. Default `DISPLAY_PREFERENCES_STORAGE_KEY`; pass the same key to `displayPreferencesScript`. */
+    storageKey?: string;
+    /** Your defaults for anything not stored yet. Pass the same to `displayPreferencesScript`. */
+    defaults?: Partial<DisplayPreferenceValues>;
+    /** Write the attributes on `<html>`. Default `true`; `false` for a preview that must not restyle the page. */
+    apply?: boolean;
+}
+interface UseDisplayPreferencesResult {
+    /** The person's choices (`system` where they left it to the system). */
+    preferences: DisplayPreferenceValues;
+    /** The theme in force: `system` resolved against `prefers-color-scheme`. */
+    resolvedTheme: 'light' | 'dark';
+    setPreference: <K extends keyof DisplayPreferenceValues>(key: K, value: DisplayPreferenceValues[K]) => void;
+    setPreferences: (next: DisplayPreferenceValues) => void;
+}
+/**
+ * The display preferences (HAR-1372): read from `localStorage`, kept in step with the system
+ * (`prefers-color-scheme`, `prefers-contrast`), with other tabs and with other users of the hook in
+ * this tab, and written to `<html>` as the attributes the tokens read. Changing one applies at once,
+ * with every transition suspended for that frame so nothing fades between themes.
+ * The server renders `defaults`; the stored choice is read before the first paint on the client
+ * (pair it with `displayPreferencesScript` in the head, so the page itself never flashes).
+ */
+declare function useDisplayPreferences({ storageKey, defaults: defaultOverrides, apply }?: UseDisplayPreferencesOptions): UseDisplayPreferencesResult;
+interface DisplayPreferencesLabels {
+    theme: string;
+    light: string;
+    dark: string;
+    system: string;
+    contrast: string;
+    contrastStandard: string;
+    contrastMore: string;
+    textScale: string;
+    textSmall: string;
+    textDefault: string;
+    textLarge: string;
+    textLarger: string;
+    motion: string;
+    motionSystem: string;
+    motionReduce: string;
+    density: string;
+    densityCompact: string;
+    densityStandard: string;
+    densityComfortable: string;
+}
+declare const DEFAULT_DISPLAY_PREFERENCES_LABELS: DisplayPreferencesLabels;
+interface ThemeSwitcherProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Controlled theme. Leave it out and the switcher keeps the preference itself (`useDisplayPreferences`). */
+    value?: ThemePreference;
+    onValueChange?: (value: ThemePreference) => void;
+    /** The storage key when uncontrolled. */
+    storageKey?: string;
+    /** `icons` shows the icons only (each keeps its word as its name); default shows icon and word. */
+    display?: 'labels' | 'icons';
+    labels?: Partial<DisplayPreferencesLabels>;
+}
+/**
+ * Light / dark / system (HAR-1372), a radio group over `Segmented`. Uncontrolled, it reads and
+ * writes the display preferences itself; controlled, it only reports.
+ */
+declare function ThemeSwitcher({ value, onValueChange, storageKey, display, labels: labelOverrides, className, ...props }: ThemeSwitcherProps): react.JSX.Element;
+interface DisplayPreferencesProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Controlled values. Leave out to keep them in `localStorage` (`useDisplayPreferences`). */
+    value?: DisplayPreferenceValues;
+    onValueChange?: (value: DisplayPreferenceValues) => void;
+    storageKey?: string;
+    /** Show only some of the five settings, in this order. Default all. */
+    settings?: readonly (keyof DisplayPreferenceValues)[];
+    labels?: Partial<DisplayPreferencesLabels>;
+}
+/**
+ * The five display settings (HAR-1372; MOTUS C-4, TENSOR A7): theme, contrast, text size, motion
+ * and density, each a labelled radio group. Put it in a preferences page or an account menu's
+ * dialog. Changes apply at once and are remembered.
+ */
+declare function DisplayPreferences({ value, onValueChange, storageKey, settings, labels: labelOverrides, className, ...props }: DisplayPreferencesProps): react.JSX.Element;
+
+interface DelayedPendingOptions {
+    /** Wait this long before showing anything (default 300 ms). `0` shows at once. */
+    delay?: number;
+    /** Once shown, keep showing at least this long (default 500 ms). */
+    minVisible?: number;
+}
+/**
+ * Whether to show a pending indicator for `pending` (motion standard §2.3): nothing for the
+ * first 300 ms, so a fast action never flashes a spinner; once shown, held at least 500 ms
+ * after it appeared, so it never flickers off the moment the work ends.
+ *
+ * ```tsx
+ * const showSpinner = useDelayedPending(query.isFetching);
+ * {showSpinner && <Spinner />}
+ * ```
+ *
+ * Use the raw `pending` for behaviour (blocking a second submit); use the result for what
+ * people see. Returns `false` on the server and on the first client render unless `delay` is 0.
+ */
+declare function useDelayedPending(pending: boolean, { delay, minVisible }?: DelayedPendingOptions): boolean;
+
+/** Under this, a pending action shows nothing new: a spinner that would flash for 150 ms is noise. */
+declare const PENDING_DELAY_MS = 300;
+/** Once a pending indicator appears, it stays at least this long so it never flickers. */
+declare const PENDING_MIN_VISIBLE_MS = 500;
+/** How long an in-place result ("Saved", "Couldn't save") holds before the control returns. */
+declare const RESULT_HOLD_MS = 1500;
+
+interface ChangeHighlightOptions {
+    /**
+     * Said through the page's polite live region when the value changes, e.g. "Status changed to
+     * Resolved by A. Novak". The highlight is the signal and its place is the location; this is
+     * the description for people who cannot see either (motion standard §2.5).
+     */
+    announce?: string;
+    /** Turn the highlight off, e.g. while the person is editing the value themselves. */
+    disabled?: boolean;
+}
+/**
+ * Flash `.uix-changed` on an element when `value` changes after mount — never on the first
+ * render (HAR-2585). A second change restarts the highlight. Compare by `Object.is`: pass a
+ * primitive (a status, a count, an `updatedAt`), not a fresh object.
+ *
+ * ```tsx
+ * const ref = useChangeHighlight<HTMLTableCellElement>(row.status, { announce: `Status: ${row.status}` });
+ * <Td ref={ref}>{row.status}</Td>
+ * ```
+ *
+ * The hook sets `data-uix-changed` on the element (React never renders that attribute, so a
+ * re-render cannot clear it) and removes it when the animation ends.
+ */
+declare function useChangeHighlight<T extends HTMLElement = HTMLElement>(value: unknown, { announce, disabled }?: ChangeHighlightOptions): RefObject<T | null>;
+/**
+ * Flash `.uix-changed` on `el` now (restarting a highlight already running). For changes that
+ * do not flow through a React value, e.g. a row a live update replaced.
+ */
+declare function flashChanged(el: HTMLElement): void;
+
+interface OptimisticRollback<T> {
+    /** The value the person asked for. */
+    attempted: T;
+    /** The value shown again. */
+    restored: T;
+    error: unknown;
+}
+interface UseOptimisticValueOptions<T> {
+    /** Called when a change fails and the value is put back, e.g. to show a toast that says what was restored. */
+    onRollback?: (rollback: OptimisticRollback<T>) => void;
+}
+interface UseOptimisticValueResult<T> {
+    /** What to show: the person's change at once, the server's value otherwise. */
+    value: T;
+    /** Show `next` now and save it; resolves when the save settles (it never rejects). */
+    set: (next: T) => Promise<void>;
+    /** A save is in flight. */
+    pending: boolean;
+    /** The last rollback, until the next change; `null` when the last change saved. */
+    rollback: OptimisticRollback<T> | null;
+    /**
+     * Counts rollbacks. Pass it to `ChangeHighlight value={rollbacks}` (or `useChangeHighlight`)
+     * so the restored element flashes; the person's own change does not.
+     */
+    rollbacks: number;
+}
+/**
+ * An optimistic value with a visible rollback (HAR-2583, motion standard §2.6). Only for
+ * reversible, personal, nearly-always-successful actions: star, pin, a reaction, mark read, a
+ * display preference, the order of one's own saved views. Never for anything the server can
+ * refuse or an auditor reads (a state transition, an assignment, an approval, a priority):
+ * those stay pessimistic, with `Button loading` and `result`.
+ *
+ * `set(next)` shows `next` at once and calls `commit(next)`. If the commit fails, the last
+ * confirmed value comes back, `rollbacks` counts up (flash the element with it), `rollback`
+ * says what happened, and `onRollback` runs so the product can say it in words. When changes
+ * overlap, only the latest one's outcome counts. While nothing is pending, `value` follows
+ * `serverValue` when it changes; a change that saved stays shown until then.
+ *
+ * ```tsx
+ * const star = useOptimisticValue(view.starred, (next) => api.star(view.id, next), {
+ *   onRollback: () => toast.error(t('starNotSaved')),
+ * });
+ * <ChangeHighlight value={star.rollbacks} variant="ring" announce={star.rollback ? t('starRestored') : undefined}>
+ *   <StarButton starred={star.value} onToggle={() => star.set(!star.value)} />
+ * </ChangeHighlight>
+ * ```
+ */
+declare function useOptimisticValue<T>(serverValue: T, commit: (next: T) => Promise<unknown>, { onRollback }?: UseOptimisticValueOptions<T>): UseOptimisticValueResult<T>;
+
+/**
+ * Say `text` through a polite live region (`[data-uix-announcer]`): the page's, or the open
+ * dialog's when `from` is inside one. The region is cleared first and filled a moment later,
+ * so the same words twice are spoken twice; a newer message replaces one not yet spoken.
+ */
+declare function announcePolite(text: string, from?: Element | null): void;
+
 /**
  * What a `renderLink` callback receives (HAR-1348). Spread it onto your router's link
  * so it keeps client navigation and prefetch: `renderLink={(p) => <NextLink {...p} />}`.
@@ -299,6 +571,14 @@ interface KbdComboProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'
  */
 declare function KbdCombo({ keys, platform, keyLabels, className, ...props }: KbdComboProps): react.JSX.Element;
 
+type ButtonResult = 'success' | 'error';
+/** The words a `Button` shows and announces for a moment after its action ends. */
+interface ButtonResultLabels {
+    success: string;
+    error: string;
+}
+declare const DEFAULT_BUTTON_RESULT_LABELS: ButtonResultLabels;
+
 type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'ghost' | 'danger' | 'link';
 /** `xs` is 24 px: the smallest hit area WCAG 2.5.8 allows, for dense tool rows (HAR-1348). */
 type ButtonSize = 'xs' | 'sm' | 'md' | 'lg';
@@ -306,7 +586,27 @@ interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     variant?: ButtonVariant;
     size?: ButtonSize;
     icon?: boolean;
+    /**
+     * The button's action is running. The button stops taking presses at once and is announced
+     * busy; the spinner appears only after `loadingDelay` and then stays at least 500 ms, so a
+     * fast action never flashes one (HAR-2580, motion standard §2.3). The button keeps its full
+     * colour while it works: a spinner, not a greyed-out control.
+     */
     loading?: boolean;
+    /** Milliseconds before the spinner shows (default 300). `0` shows it at once. */
+    loadingDelay?: number;
+    /**
+     * How the button's last action ended (HAR-2581). When it changes to `success` or `error`,
+     * or an action ends with one, the label crossfades to a check and `resultLabels.success`
+     * ("Done") or an alert mark and `resultLabels.error` ("Failed") for 1.5 s, announced
+     * politely, then returns. Never on the first render. The button is always as wide as its
+     * widest wording, so nothing beside it moves. Pass `null` while there is no result (keep
+     * the prop defined); say what failed and how to recover somewhere that stays, such as a
+     * field error or a toast. e.g. `result={m.isSuccess ? 'success' : m.isError ? 'error' : null}`
+     */
+    result?: ButtonResult | null;
+    /** The result words, e.g. `{ success: 'Assigned', error: 'Not assigned' }`; or `UixLabelsProvider` `buttonResult`. */
+    resultLabels?: Partial<ButtonResultLabels>;
     /**
      * Let a long label wrap onto more lines: the size becomes a minimum height instead of a fixed
      * one (HAR-1813, WCAG 1.4.10 reflow). For human-language labels on public or narrow screens;
@@ -316,10 +616,11 @@ interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     /**
      * The button's keyboard shortcut, in `KbdCombo` key names: `['A']`, `['Mod', 'Enter']`
      * (HAR-2031). Hover or focus shows the keys in a hint above the button (an icon button's
-     * `aria-label` before them), and the button gets `aria-keyshortcuts` for the viewer's platform
-     * (⌘ / Meta on Apple, Ctrl / Control elsewhere), unless you pass `aria-keyshortcuts` yourself.
-     * Inside a `Tooltip` the Tooltip shows the keys in its own bubble. The kit only shows the
-     * shortcut: the product binds the key.
+     * `aria-label` before them; ⌘ on Apple, Ctrl elsewhere). Screen readers hear the keys once, as
+     * the button's description after any `aria-describedby` of yours ("Control+Enter"), the same
+     * rule as a `Tooltip` with a shortcut (HAR-2416). Inside a `Tooltip` the Tooltip shows and says
+     * the keys. An `aria-keyshortcuts` you pass is kept as it is. The kit only shows the shortcut:
+     * the product binds the key.
      */
     shortcut?: KeyShortcut;
     children?: ReactNode;
@@ -340,13 +641,19 @@ interface ButtonLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     disabled?: boolean;
     /** Your router's link (`(p) => <NextLink {...p} />`); default a plain `<a>`. */
     renderLink?: UixRenderLink;
+    /**
+     * The link's keyboard shortcut, as on `Button` (HAR-2416): hover or keyboard focus shows the
+     * keys in a hint above it, and screen readers hear them once as its description. Not shown
+     * while `disabled`. The kit only shows the shortcut: the product binds the key.
+     */
+    shortcut?: KeyShortcut;
     children?: ReactNode;
 }
 /**
  * A link that looks like a `Button` (HAR-1348; TENSOR A4/B5, MOTUS C-3). Use it when the
  * action navigates; use `Button` when it acts in place.
  */
-declare function ButtonLink({ href, variant, size, icon, wrap, disabled, renderLink, className, children, onClick, ...props }: ButtonLinkProps): react.JSX.Element;
+declare function ButtonLink({ href, variant, size, icon, wrap, disabled, renderLink, shortcut, className, children, onClick, ...props }: ButtonLinkProps): react.JSX.Element;
 interface ButtonGroupProps {
     children?: ReactNode;
     className?: string;
@@ -736,6 +1043,91 @@ declare function proposeMove(span: {
     minutes?: number;
 }, timeZone: string): MoveProposal;
 
+/** What a span of a resource's day is: open to book, booked, or not working. */
+type SchedulingAvailabilityKind = 'free' | 'booked' | 'off';
+/** One column of the resource day, e.g. a practitioner. */
+interface SchedulingResource {
+    id: string;
+    /** The column heading and the start of every slot's accessible name. */
+    label: string;
+    /** A second line under the heading, e.g. the speciality or the room. */
+    description?: string;
+}
+/** A stretch of one resource's day, as the server composed it. */
+interface SchedulingResourceSpan {
+    id: string;
+    resourceId: string;
+    /** ISO 8601 instants, half-open `[start, end)`. */
+    start: string;
+    end: string;
+    kind: SchedulingAvailabilityKind;
+    /** Shown on the span, e.g. the patient's name on a booking or "Lunch" on time off. */
+    label?: string;
+    /** The complete accessible name, in the consumer's words. Replaces the built one. */
+    accessibleName?: string;
+}
+/** One row of the slot axis. */
+interface ResourceDaySlot {
+    /** Epoch milliseconds of the slot's start and end. */
+    start: number;
+    end: number;
+    /** The local time it starts, `HH:MM`, in the display zone. */
+    label: string;
+}
+interface ResourceDaySlotOptions {
+    /** The first local time shown, `HH:MM`. Default `'07:00'`. */
+    dayStart?: string;
+    /** The local time the axis ends, `HH:MM` (exclusive). Default `'19:00'`. */
+    dayEnd?: string;
+    /** Minutes per slot. Default 15. */
+    slotMinutes?: number;
+}
+/** One drawn piece of a column: a bookable slot of a free span, a booking, or time off. */
+interface ResourceDayItem {
+    key: string;
+    span: SchedulingResourceSpan;
+    kind: SchedulingAvailabilityKind;
+    /** Epoch milliseconds of what this piece covers (a free span is cut at slot edges). */
+    start: number;
+    end: number;
+    /** Slots from the top of the axis to the piece's start (fractional). */
+    offset: number;
+    /** Slots the piece is long (fractional). */
+    length: number;
+    lane: number;
+    lanes: number;
+    /** The span starts before or ends after the axis. */
+    continuesBefore: boolean;
+    continuesAfter: boolean;
+}
+/**
+ * The slot axis of `date` in `timeZone`: one slot per `slotMinutes` of real time from the first
+ * local time at or after `dayStart` to the last before `dayEnd`. On a clock-change day the axis
+ * is as long as the day really is (a skipped hour has no slots; a repeated hour has two sets).
+ */
+declare function resourceDaySlots(date: string, timeZone: string, options?: ResourceDaySlotOptions): ResourceDaySlot[];
+/**
+ * Where the spans of one resource go on the slot axis. Free spans are cut at slot edges, so each
+ * bookable slot is its own piece; bookings and time off stay whole. Pieces outside the axis are
+ * dropped, pieces across its edges are clipped. Overlapping pieces (a double booking) get lanes.
+ */
+declare function layoutResourceColumn(spans: readonly SchedulingResourceSpan[], slots: readonly ResourceDaySlot[]): ResourceDayItem[];
+/** The stretches of the axis no span covers: shown as "no schedule", never as free. */
+declare function resourceDayGaps(items: readonly ResourceDayItem[], slots: readonly ResourceDaySlot[]): Array<{
+    start: number;
+    end: number;
+}>;
+
+/** What `onSelectSlot` receives: the resource, the piece's own start and end, and the span it belongs to. */
+interface SchedulingSlotSelection {
+    resourceId: string;
+    /** ISO 8601 instants of the piece: one slot of a free span, or the whole booking. */
+    start: string;
+    end: string;
+    kind: Exclude<SchedulingAvailabilityKind, 'off'>;
+    span: SchedulingResourceSpan;
+}
+
 interface TimeGridEntryContext {
     /** Whole text lines that fit in the item: 0 shows the markers only. */
     availableLines: number;
@@ -935,6 +1327,18 @@ interface SchedulingCalendarLabels {
     moveCancelled?: string;
     /** Announced when the time asked for does not exist that day. `{time}` is the time used instead. */
     gapForward?: string;
+    /** Names the resource day (HAR-983). `{date}` placeholder. */
+    resourceGrid?: string;
+    /** The words for the kinds of a resource span. */
+    availability?: Partial<Record<SchedulingAvailabilityKind, string>>;
+    /** Time of a resource that no span covers: no schedule, which is not free. */
+    noSchedule?: string;
+    /** A resource slot's or booking's accessible name. `{resource}`, `{start}`, `{end}`, `{kind}`, `{label}`. */
+    slotName?: string;
+    /** How to move in the resource day, read with it. */
+    resourceHint?: string;
+    /** The resource day with no resources. */
+    noResources?: string;
 }
 declare const DEFAULT_SCHEDULING_CALENDAR_LABELS: SchedulingCalendarLabels;
 interface SchedulingCalendarProps {
@@ -1075,14 +1479,49 @@ interface SchedulingCalendarProps {
     topLaneCap?: number;
     /** Lanes side by side in one day column of the time grid, at most. Fewer are used when the column is narrow. Default 4. */
     maxLanes?: number;
+    /**
+     * With `view="day"`, one column per resource (a practitioner, a room) instead of the time grid
+     * (HAR-983). Their stretches of the day come from `resourceSpans`; a time no span covers is
+     * shown as "no schedule", never as free.
+     */
+    resources?: SchedulingResource[];
+    /** The free, booked and off stretches of each resource, as the server composed them. */
+    resourceSpans?: SchedulingResourceSpan[];
+    /** Minutes per slot of the resource day: each free span is cut into bookable slots of this length. Default 15. */
+    slotMinutes?: number;
+    /** The first local time of the resource day's axis, `HH:MM`. Default `'07:00'`. */
+    dayStart?: string;
+    /** The local time the resource day's axis ends, `HH:MM`. Default `'19:00'`. */
+    dayEnd?: string;
+    /** Called by a click, Enter or Space on a free slot (its own start and end) or a booking. */
+    onSelectSlot?: (slot: SchedulingSlotSelection) => void;
+    /** Marks the slot or booking that holds this instant for this resource, e.g. while its popover is open. */
+    selectedSlot?: {
+        resourceId: string;
+        start: string;
+    };
+    /**
+     * `auto` (default): columns, and a list of one resource after another when the calendar is
+     * narrower than `resourceListBelow`. `columns` or `list` fixes one.
+     */
+    resourceLayout?: 'auto' | 'columns' | 'list';
+    /** The width in CSS pixels under which `auto` shows the list. Default 480. */
+    resourceListBelow?: number;
+    /**
+     * The first load shows skeletons; a refetch keeps what is on screen, dimmed and `aria-busy`
+     * (the resource day; the other views show `labels.loading` instead).
+     */
     loading?: boolean;
     error?: string;
     onRetry?: () => void;
     className?: string;
     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, onSelectOverlay, filter, renderEntry, locale, weekStartsOn, formatDate, formatInstant: formatInstantProp, maxEntriesPerDay, onShowMore, renderDayBadge, days: dayInfo, dayEntries, spanLayout, windowLaneCap, spanLaneCap, legend, legendCaption, showHeader, notice, emptyNote, onSelectDate, agendaGroups, agendaHeadingLevel, virtualizeAbove, monthDensity, timeGrid, now, canMove, step, onProposeMove, topLaneCrossMidnightMinutes, topLaneCap, maxLanes, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
+/**
+ * Month/week/day/agenda calendar for UTC ranges rendered in an explicit IANA time zone. With
+ * `resources`, the day view is one column per resource (HAR-983).
+ */
+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, agendaGroups, agendaHeadingLevel, virtualizeAbove, monthDensity, timeGrid, now, canMove, step, onProposeMove, topLaneCrossMidnightMinutes, topLaneCap, maxLanes, resources, resourceSpans, slotMinutes, dayStart, dayEnd, onSelectSlot, selectedSlot, resourceLayout, resourceListBelow, loading, error, onRetry, className, labels: labelOverrides, }: SchedulingCalendarProps): react.JSX.Element;
 
 /**
  * Every word the picker renders or announces (TENSOR RX-125, UIX-13). `{start}` and
@@ -1105,6 +1544,13 @@ interface DateRangePickerLabels {
     fieldStart: string;
     /** Field mode: the trigger's text for a range; `{start}`, `{end}`. */
     fieldRange: string;
+    /**
+     * The picker's name: the heading of the inline months, the field's hidden name and its popover's
+     * `aria-label` (HAR-2432). The `label` prop wins.
+     */
+    label: string;
+    /** Shown when the range is invalid (an end before the start, or `invalid`). The `invalidMessage` prop wins. */
+    invalidMessage: string;
 }
 declare const DEFAULT_DATE_RANGE_PICKER_LABELS: DateRangePickerLabels;
 interface DateRangePickerProps {
@@ -1116,9 +1562,12 @@ interface DateRangePickerProps {
     min?: string;
     max?: string;
     isDateDisabled?: (date: string) => boolean;
+    /** Default: `UixLabelsProvider` `dateFormat.locale`, then the viewer's. */
     locale?: string;
+    /** Default: `labels.label` ("Choose date range"). */
     label?: string;
     invalid?: boolean;
+    /** Default: `labels.invalidMessage`. */
     invalidMessage?: string;
     disabled?: boolean;
     className?: string;
@@ -1138,7 +1587,7 @@ interface DateRangePickerProps {
      * bars. It closes once the range has both ends; Escape closes it and returns focus.
      */
     mode?: 'inline' | 'field';
-    /** Field mode: how the trigger writes a date. Default: the locale's numeric date. */
+    /** Field mode: how the trigger writes a date. Default: `UixLabelsProvider` `dateFormat.formatDate`, then the locale's numeric date. */
     formatDate?: (date: string) => string;
     /** Field mode: lands on the trigger, so a `<label htmlFor>` or `<Field>` names it. */
     id?: string;
@@ -1155,7 +1604,82 @@ interface DateRangePickerProps {
  * Controlled date-range picker using the UIx calendar language: two months inline, or with
  * `mode="field"` a form control that opens them in a popover.
  */
-declare function DateRangePicker({ labels: labelOverrides, ...props }: DateRangePickerProps): react.JSX.Element;
+declare function DateRangePicker({ labels: labelOverrides, ...rest }: DateRangePickerProps): react.JSX.Element;
+
+/** Every word `TimePicker` renders or announces. */
+interface TimePickerLabels {
+    /** The list button's name while no time is set. */
+    open: string;
+    /** The list button's name with a time set; `{time}` is the time as the field shows it. */
+    openSelected: string;
+    /** The list of times (the popover's and the listbox's name). */
+    list: string;
+    /** Shown when the typed text is not a time; `{example}` is a time in the field's own shape. */
+    invalidTime: string;
+    /** Shown when the typed time is before `min`; `{min}`. */
+    tooEarly: string;
+    /** Shown when the typed time is after `max`; `{max}`. */
+    tooLate: string;
+    /** Shown when the typed time is outside an overnight range (`min` after `max`); `{min}`, `{max}`. */
+    outside: string;
+}
+declare const DEFAULT_TIME_PICKER_LABELS: TimePickerLabels;
+/** Why typed text was refused: not a time, or a time before `min` / after `max`. */
+type TimeInputProblem = 'format' | 'early' | 'late' | 'outside';
+interface TimePickerProps {
+    /** The time as `HH:mm` (24-hour), or `null` for none. */
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+    /** Minutes the arrow keys step the minutes by, and between the times in the list. Default 15. */
+    minuteStep?: number;
+    /**
+     * First and last time that can be chosen (`HH:mm`, inclusive). A `min` after `max` (22:00 to
+     * 06:00) is an overnight range: it wraps round midnight, in the keys, the list and the check.
+     */
+    min?: string;
+    max?: string;
+    /**
+     * The locale that writes the time: 14:30 in `de`, 2:30 PM in `en-US`. Default: `UixLabelsProvider`
+     * `dateFormat.locale`, then the viewer's.
+     */
+    locale?: string;
+    /** `true` writes 2:30 PM, `false` 14:30, whatever the locale. */
+    hour12?: boolean;
+    placeholder?: string;
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    /** Submits the `HH:mm` value under this name (a hidden input), whatever the field shows. */
+    name?: string;
+    /** Lands on the text input, so a `<label htmlFor>` or `<Field>` names it. */
+    id?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    'aria-invalid'?: AriaAttributes['aria-invalid'];
+    'aria-required'?: AriaAttributes['aria-required'];
+    /** Where the list opens. Default `'bottom-start'`; it flips and shifts to stay on screen. */
+    placement?: Placement;
+    /** Told when typed text is refused, and `null` once the field is fine again. */
+    onInputProblem?: (problem: TimeInputProblem | null) => void;
+    onOpenChange?: (open: boolean) => void;
+    /** Translatable words; English defaults in {@link DEFAULT_TIME_PICKER_LABELS}. */
+    labels?: Partial<TimePickerLabels>;
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * A time of day as a form field (HAR-1835), beside `DatePicker`: a text input that shows the time
+ * in the locale's shape (14:30 in German, 2:30 PM in en-US) and reads a typed one (`1430`, `9`,
+ * `2:30 pm`) on Enter and when focus leaves it; a clock button opens the times at `minuteStep` in a
+ * list. ArrowUp / ArrowDown step the part the caret is in (the hour, or the minutes by
+ * `minuteStep`), PageUp / PageDown step the hour, Alt+ArrowDown opens the list. Text that is not a
+ * time, or a time outside `min` / `max`, marks the field invalid, says why and leaves `value` alone.
+ * The value is `HH:mm`, what `<input type="time">` holds.
+ */
+declare const TimePicker: react.ForwardRefExoticComponent<TimePickerProps & react.RefAttributes<HTMLInputElement>>;
 
 /** Every word `DatePicker` renders or announces. */
 interface DatePickerLabels {
@@ -1192,6 +1716,8 @@ interface DatePickerProps {
     /**
      * How the field writes a date. Default: the locale's numeric date (22.11.2026, 11/22/2026).
      * Pass `parseDate` with it when your format is not three numbers, so typing still works.
+     * `formatDate`, `parseDate`, `locale` and `placeholder` default to `UixLabelsProvider`
+     * `dateFormat`, so one provider sets the format of every date field (HAR-2432).
      */
     formatDate?: (date: string) => string;
     /** Read typed text into `YYYY-MM-DD`, or `null` when it is not a date. Default: ISO or the locale's order. */
@@ -1266,14 +1792,18 @@ interface DateTimePickerProps extends Omit<DatePickerProps, 'value' | 'onValueCh
     timeZone?: string;
     /** Text shown instead of the zone's short name ("Vienna time", "UTC+2"); `null` shows none. */
     timeZoneLabel?: string | null;
-    /** Minutes between time steps. Default 1. */
+    /** Minutes the time's arrow keys step by, and between the times in its list. Default 15. */
     minuteStep?: number;
+    /** Words of the time field (its list button, list and messages); `UixLabelsProvider` `timePicker` too. */
+    timeLabels?: Partial<TimePickerLabels>;
+    /** `true` writes the time as 2:30 PM, `false` as 14:30, whatever the locale. */
+    hour12?: boolean;
     /** The time a date gets when it is chosen before any time. Default `'00:00'`. */
     defaultTime?: string;
     labels?: Partial<DateTimePickerLabels>;
 }
 /**
- * A date and a time as one field (HAR-1383): the {@link DatePicker} and a time input, with the
+ * A date and a time as one field (HAR-1383): the {@link DatePicker} and a {@link TimePicker} (HAR-1835), with the
  * time zone the pair is in shown beside them. The value is `YYYY-MM-DDTHH:mm`, the shape
  * `datetime-local` uses, so it replaces that input without changing what a form submits.
  * Clearing the date clears the value; a time alone is not a value.
@@ -1742,6 +2272,12 @@ interface FilterChoice {
 }
 type TextFilterOperator = 'contains' | 'not-contains' | 'is' | 'is-not' | 'starts-with';
 type NumberFilterOperator = 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte' | 'between';
+/**
+ * A date condition (HAR-1832). `on`, `before` and `after` take one day in `from`; `between` takes
+ * `from` and `to`, both inclusive. "Before" excludes the day and "after" starts the next day:
+ * `dateFilterBounds` turns each into the half-open range a query needs.
+ */
+type DateFilterOperator = 'on' | 'before' | 'after' | 'between';
 type FilterValue = {
     kind: 'enum';
     values: string[];
@@ -1758,12 +2294,24 @@ type FilterValue = {
     kind: 'date-range';
     from?: string;
     to?: string;
+}
+/** A date with a condition (HAR-1832); `YYYY-MM-DD`. A saved `between` stays `between`, even of one day. */
+ | {
+    kind: 'date';
+    operator: DateFilterOperator;
+    from?: string;
+    to?: string;
 } | {
     kind: 'boolean';
     value?: boolean;
 } | {
     kind: 'reference';
     values: FilterChoice[];
+}
+/** Free-text values typed in as tags (HAR-1832), e.g. several hostnames; matched by the product. */
+ | {
+    kind: 'tags';
+    values: string[];
 };
 type FilterValueKind = FilterValue['kind'];
 /**
@@ -1785,8 +2333,15 @@ interface FilterField {
     options?: readonly FilterChoice[];
     /** `reference`: finds records to pick; rejected promises show the error state. */
     onSearch?: (query: string) => Promise<readonly FilterChoice[]>;
+    /**
+     * `reference`: labels for chosen ids that arrived without one (a saved view restores ids).
+     * The editor asks once for every id whose label is missing or equal to the id.
+     */
+    resolveLabels?: (ids: readonly string[]) => Promise<readonly FilterChoice[]>;
     /** `text` / `number`: the operators offered, in order. Default: all of the kind. */
     operators?: readonly (TextFilterOperator | NumberFilterOperator)[];
+    /** `date`: the conditions offered, in order. Default: on, before, after, between. */
+    dateOperators?: readonly DateFilterOperator[];
     /** `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. */
@@ -1813,14 +2368,38 @@ interface FilterSummaryLabels {
     more: string;
     /** An `enum` value equal to a preset: `{label}` (the preset), `{field}`. Default `{label}`. */
     preset?: string;
+    /** `date` conditions (HAR-1832), `{date}`. Default "{date}", "before {date}", "after {date}". */
+    on?: string;
+    before?: string;
+    after?: string;
 }
 declare const DEFAULT_FILTER_SUMMARY_LABELS: FilterSummaryLabels;
 declare const TEXT_FILTER_OPERATORS: readonly TextFilterOperator[];
 declare const NUMBER_FILTER_OPERATORS: readonly NumberFilterOperator[];
+declare const DATE_FILTER_OPERATORS: readonly DateFilterOperator[];
 /** 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 half-open range a `date` filter means, for a query (HAR-1832): `{ from }` is the first day
+ * included, `{ until }` the first day NOT included, either may be missing. "On 5 Oct" is
+ * `[5 Oct, 6 Oct)`, "before 5 Oct" is `[…, 5 Oct)`, "after 5 Oct" is `[6 Oct, …)`, "between 1 and
+ * 5 Oct" is `[1 Oct, 6 Oct)`. A `date-range` value reads as `between` with optional ends. Empty
+ * values give `{}`.
+ */
+declare function dateFilterBounds(input: FilterValue | undefined): {
+    from?: string;
+    until?: string;
+};
+/** True for a chosen reference whose label is missing or only repeats its id (restored from an id). */
+declare const isUnresolvedChoice: (choice: FilterChoice) => boolean;
+/**
+ * Fills in the labels of a `reference` value restored from ids (HAR-1832), with
+ * `field.resolveLabels`. Other values, and values whose labels are all known, come back as they
+ * are. Ids the resolver does not return keep the label they had.
+ */
+declare function resolveFilterLabels(field: FilterField, value: FilterValue | undefined): Promise<FilterValue | undefined>;
 /**
  * The first of `field.presets` whose values equal the value's as a set, or undefined. Only an
  * `enum` value can match a preset.
@@ -1837,10 +2416,10 @@ interface SummarizeFilterOptions {
 }
 /**
  * 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`
+ * 01.10.2026 – 05.10.2026", "Created: before 05.10.2026", "Host: db-01, db-02 +1", "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;
+declare function summarizeFilter(field: FilterField, input: FilterValue | undefined, options?: SummarizeFilterOptions): string;
 
 interface FilterEditorLabels {
     apply: string;
@@ -1867,7 +2446,15 @@ interface FilterEditorLabels {
     remove: string;
     /** Names the row of `field.presets` chips. Optional so existing label objects still type-check; default "Presets". */
     presets?: string;
+    /** `tags` (HAR-1832): the field that takes a new value, and its hint. Optional, like `presets`. */
+    addTag?: string;
+    /** `tags`: how to add one, read with the field. */
+    addTagHint?: string;
+    /** `date` (HAR-1832): the date of on / before / after. Optional, like `presets`. */
+    date?: string;
     operators: Record<TextFilterOperator | NumberFilterOperator, string>;
+    /** `date` conditions (HAR-1832). Optional, like `presets`. */
+    dateOperators?: Partial<Record<DateFilterOperator, string>>;
 }
 declare const DEFAULT_FILTER_EDITOR_LABELS: FilterEditorLabels;
 interface FilterEditorProps {
@@ -1875,7 +2462,12 @@ interface FilterEditorProps {
     /** Undefined means "not filtered yet". */
     value: FilterValue | undefined;
     onValueChange: (value: FilterValue) => void;
-    onApply: () => void;
+    /**
+     * Apply the filter: the Apply button, or Enter in any field (HAR-1832). Gets the value to
+     * apply, which already holds a tag still being typed: read it rather than your state, which
+     * has not caught up when Enter applies in the same event.
+     */
+    onApply: (value: FilterValue) => void;
     onClear: () => void;
     labels?: Partial<FilterEditorLabels>;
     /** Show an option filter above an enum list once it has more options than this. Default 8. */
@@ -1885,8 +2477,9 @@ interface FilterEditorProps {
 }
 /**
  * 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`
+ * multi-select, text or number with a condition, a date range, a date with a condition
+ * (on / before / after / between), yes/no, free-text tags, or records found by an async search
+ * (restored ids get their labels from `field.resolveLabels`). Enter applies in every kind. 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.
@@ -1941,7 +2534,8 @@ interface SelectLabels {
     results: string;
 }
 interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
-    size?: 'sm' | 'md';
+    /** `sm` 28 px, `md` 36 px (default), `lg` 44 px, the public touch-target size (HAR-1812). */
+    size?: 'sm' | 'md' | 'lg';
     /** The options as data, instead of `<option>` / `<optgroup>` children. */
     options?: readonly (SelectOption | SelectGroup)[];
     /**
@@ -1978,7 +2572,7 @@ interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'siz
  * 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,
+ * select element (the form proxy) 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.
  */
@@ -2374,8 +2968,19 @@ interface SearchSuggestProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onCha
     onValueChange: (value: string) => void;
     /** The suggestions to show, best first. The consumer filters; this component only renders. */
     options: readonly SearchSuggestOption[];
-    /** Called when a row is chosen by click or Enter. The list closes afterwards. */
-    onSelect: (id: string, option: SearchSuggestOption) => void;
+    /**
+     * Called when a row is chosen by click or Enter. The list closes afterwards. Optional with
+     * `freeText`, where choosing a row also puts its title in the field.
+     */
+    onSelect?: (id: string, option: SearchSuggestOption) => void;
+    /**
+     * A text field with suggestions, not a search (HAR-2465): the value is the text. Enter keeps
+     * what was typed and never submits the surrounding form; no row is picked unless the person
+     * moves to it (ArrowDown / ArrowUp, then Enter) or clicks it, and then its title replaces the
+     * text (`onValueChange`) without submitting either. Blur, Tab and Escape keep the text; while
+     * `loading`, Enter does nothing. No magnifier is drawn.
+     */
+    freeText?: boolean;
     /** Accessible name of the field (there is no visible label; the placeholder is not a label). */
     label: string;
     placeholder?: string;
@@ -2434,6 +3039,15 @@ interface SearchSuggestProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onCha
     inputId?: string;
     /** `aria-describedby` of the input (hint and error text from a `Field`). */
     inputDescribedBy?: string;
+    /**
+     * Ids of the visible label(s) that name the input (HAR-1834). With them, or with a
+     * `<label for={inputId}>`, the input gets no `aria-label`, so the visible label is its name.
+     */
+    inputLabelledBy?: string;
+    /** The field cannot be typed in and the list never opens (HAR-1834). */
+    disabled?: boolean;
+    /** Marks the input `aria-invalid` (an empty required field with an error, HAR-1834). */
+    invalid?: boolean;
 }
 /**
  * A search field with a suggestion list underneath: the "search and jump" pattern of Windows
@@ -2442,7 +3056,7 @@ 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, idle, note, error, shortcutHint, clearLabel: clearLabelProp, status, size, open: openProp, strategy, onOpenChange, inputRef, autoFocus, name, inputId, inputDescribedBy, className, onBlur, ...props }: SearchSuggestProps): react.JSX.Element;
+declare function SearchSuggest({ value, onValueChange, options, onSelect, freeText, label, placeholder, highlight, heading, headingAction, footer, loading, loadingLabel, empty, idle, note, error, shortcutHint, clearLabel: clearLabelProp, status, size, open: openProp, strategy, onOpenChange, inputRef, autoFocus, name, inputId, inputDescribedBy, inputLabelledBy, disabled, invalid, className, onBlur, ...props }: SearchSuggestProps): react.JSX.Element;
 
 interface EntityPickerLabels {
     /** Accessible name of the search field while picking. */
@@ -2466,12 +3080,23 @@ interface EntityPickerLabels {
     more: string;
     /** Polite count when there are more matches than shown. `{count}` is the number shown. */
     resultsMore: string;
+    /**
+     * Shown, with no Retry, when the search failed for good (HAR-1834): `onSearch` rejected with
+     * `{ retryable: false }` (and no `message`), or `isRetryable` said no. E.g. no permission.
+     */
+    forbidden: string;
     /** Shown in the open list while the query is shorter than `minQueryLength`. `{count}`. */
     tooShort: string;
     /** The same when `minQueryLength` is 1. */
     typeToSearch: string;
 }
 declare const DEFAULT_ENTITY_PICKER_LABELS: EntityPickerLabels;
+/** What `onSearch` may reject with when trying again cannot help (HAR-1834). */
+interface EntityPickerSearchError {
+    retryable: false;
+    /** Shown instead of the `forbidden` words. */
+    message?: string;
+}
 /** What `onSearch` may resolve to when it knows its list was cut off. */
 interface EntityPickerSearchResult {
     options: readonly SearchSuggestOption[];
@@ -2485,9 +3110,15 @@ interface EntityPickerProps {
     /**
      * Finds records for the query; a rejection shows the error state with a Retry row. Resolve
      * with the options, or with `{ options, hasMore: true }` when the list was cut off (a page of
-     * 20 out of many): the list then says that more match.
+     * 20 out of many): the list then says that more match. Reject with
+     * `{ retryable: false, message? }` (an {@link EntityPickerSearchError}) when trying again
+     * cannot help, e.g. no permission: the error shows without Retry.
      */
     onSearch: (query: string) => Promise<readonly SearchSuggestOption[] | EntityPickerSearchResult>;
+    /** Decide from the rejection whether Retry is offered. Default: not for `{ retryable: false }`. */
+    isRetryable?: (error: unknown) => boolean;
+    /** Ids of the visible label that names the search field (instead of `label`). */
+    'aria-labelledby'?: string;
     /** The field's name (the visible label usually comes from a surrounding `Field`). */
     label: string;
     /** Id of the control, for `Field htmlFor`/`label for`. */
@@ -2518,13 +3149,19 @@ interface EntityPickerProps {
  * 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;
+declare function EntityPicker({ value, onValueChange, onSearch, isRetryable, label, id, name, placeholder, minQueryLength, delay, disabled, invalid, 'aria-describedby': describedBy, 'aria-labelledby': labelledBy, renderValue, labels: labelOverrides, className, }: EntityPickerProps): react.JSX.Element;
 
 interface TreeNodeData {
     id: string;
     label: ReactNode;
     /** Plain-text label for keyboard typeahead when `label` is not a string (UIX-A11Y-2). */
     typeaheadLabel?: string;
+    /**
+     * The row's accessible name when `label` is rich (an avatar, a name and a meta line) and only
+     * part of it should be spoken, e.g. the person's name (HAR-1828). By default a row is named by
+     * its own `label`, never by its children.
+     */
+    ariaLabel?: string;
     icon?: ReactNode;
     children?: TreeNodeData[];
     /**
@@ -2558,6 +3195,8 @@ interface TreeNodeProps {
     rowToggles?: boolean;
     /** Ids of nodes whose children are loading (`aria-busy`). */
     busy?: ReadonlySet<string>;
+    /** Scopes the ids that name each row by its own label (HAR-1828). Set by `Tree`. */
+    treeId?: string;
 }
 interface TreeProps extends Omit<HTMLAttributes<HTMLUListElement>, 'onSelect' | 'onChange'> {
     nodes: TreeNodeData[];
@@ -2720,11 +3359,11 @@ declare function OrgChart({ nodes, expanded: controlledExpanded, defaultExpanded
 
 /** Every word `InlineEdit` renders or announces. `{label}` is the field's name. */
 interface InlineEditLabels {
-    /** Added to the view button's name after the value: "…, Edit {label}". */
+    /** Added to the view button's name after the value: "…, Edit {label}"; the icon trigger's whole name. */
     edit: string;
     save: string;
     cancel: string;
-    /** Polite status while `onSave` runs. */
+    /** Polite status while `onSave` runs (shown after 300 ms, so a fast save does not flash it). */
     saving: string;
     /** Polite status after a save. */
     saved: string;
@@ -2732,50 +3371,114 @@ interface InlineEditLabels {
     failed: string;
     /** What the view shows when the value is empty and no `placeholder` was given. */
     empty: string;
+    /** Visually hidden before a `readOnlyReason`, so it is read as one: "Read-only: …". */
+    readOnly: string;
 }
 declare const DEFAULT_INLINE_EDIT_LABELS: InlineEditLabels;
+/** Where an `InlineEdit` is (HAR-1833). `saved` holds until the field is opened again. */
+type InlineEditState = 'idle' | 'editing' | 'saving' | 'saved' | 'error';
 /** What a custom editor receives. Spread the field props onto your control. */
-interface InlineEditEditorProps {
+interface InlineEditEditorProps<T = string> {
     /** The draft. */
-    value: string;
-    onChange: (next: string) => void;
-    /** Save the draft (what Enter does in the default editor). */
-    save: () => void;
+    value: T;
+    /** Change the draft. With `commit="change"` this also saves it. Ignored while a save runs. */
+    onChange: (next: T) => void;
+    /**
+     * Save the draft (what Enter does in the default editor). Pass the value to save one you
+     * just chose: `save(next)` does not wait for the draft to update, so it never saves a stale one.
+     */
+    save: (next?: T) => void;
     cancel: () => void;
-    /** `id`, the accessible name, the error wiring and `disabled` while saving. */
+    /** `id`, the accessible name, the error wiring, and the busy state while saving. */
     field: {
         id: string;
         'aria-label': string;
         'aria-describedby': string | undefined;
         'aria-invalid': true | undefined;
+        /** True once a save has run for 300 ms (changes are ignored from its start, so a fast save never greys the control). */
         disabled: boolean;
+        /** The same moment as `disabled`, for a text control that should keep focus and its text selectable. */
+        readOnly: boolean;
     };
 }
-interface InlineEditProps {
+/** What `renderError` receives besides the rejection itself. */
+interface InlineEditErrorContext<T = string> {
+    /** The rejection's message, else `labels.failed`: what the default rendering shows. */
+    message: ReactNode;
+    /** The draft that failed. */
+    draft: T;
+    /** Send the draft again. Show it when a retry can help (a timeout, not a refusal). */
+    retry: () => void;
+    /** Close the editor and drop the draft, e.g. after "Reload latest" on a version conflict. */
+    cancel: () => void;
+}
+interface InlineEditProps<T = string> {
     /** The saved value. */
-    value: string;
+    value: T;
     /**
      * Save the new value. Return a promise to show the pending state; a rejection keeps the
      * editor open with the error under it (the rejection's message, else `labels.failed`).
+     * The editor waits for it: the value shows as saved only once it resolves.
      */
-    onSave: (next: string) => void | Promise<void>;
+    onSave: (next: T) => void | Promise<unknown>;
     /** The field's name: "Title", "Due date". It names the edit button and the editor. */
     label: string;
-    /** How the saved value shows. Default: the text itself. */
-    renderView?: (value: string) => ReactNode;
+    /**
+     * How the saved value shows. Default: the text itself (`String(value)`); pass it for any
+     * value that is not a string (an option, a person, a time window).
+     */
+    renderView?: (value: T) => ReactNode;
     /**
      * A custom editor: a `Select`, a `Combobox`, a date field. Spread `field` onto the control.
-     * Default: an `Input`, or a `Textarea` with `multiline`.
+     * Default: an `Input`, or a `Textarea` with `multiline` (string values only).
      */
-    renderEditor?: (props: InlineEditEditorProps) => ReactNode;
+    renderEditor?: (props: InlineEditEditorProps<T>) => ReactNode;
     /** Edit in a textarea: Enter adds a line, Ctrl/⌘+Enter saves. */
     multiline?: boolean;
     /** Return a message to refuse the draft; nothing is saved while it returns one. */
-    validate?: (next: string) => ReactNode | undefined;
+    validate?: (next: T) => ReactNode | undefined;
+    /** Whether two values are the same (an unchanged draft saves nothing). Default `Object.is`. */
+    equals?: (a: T, b: T) => boolean;
+    /** Whether a value counts as empty (the view then shows `placeholder`). Default: `null`, `undefined` or `''`. */
+    isEmpty?: (value: T) => boolean;
+    /**
+     * When the draft is saved (HAR-1833).
+     * `'explicit'` (default): Enter or Save only; leaving the field keeps the draft open.
+     * `'blur'`: also when focus leaves the editor (text fields of a record).
+     * `'change'`: as soon as the editor reports a change (a select, a toggle, a date), with no
+     * Save button; leaving it unchanged closes it.
+     */
+    commit?: 'explicit' | 'blur' | 'change';
     /** Shown in the view while the value is empty, e.g. "Add a description". */
     placeholder?: ReactNode;
-    /** Read-only: the value shows as plain text, with no edit button. */
+    /** Read-only: the value shows as plain text, with no edit control. */
     disabled?: boolean;
+    /**
+     * Why the field cannot be edited here ("Set by the integration"). Makes it read-only and
+     * shows the reason under the value, which is described by it.
+     */
+    readOnlyReason?: ReactNode;
+    /**
+     * `'value'` (default): the whole value is the button, named "{value}, Edit {label}".
+     * `'icon'`: the value is plain text and a pencil button after it is named only "Edit {label}"
+     * (for a value that is itself a link, a chip or long text).
+     */
+    trigger?: 'value' | 'icon';
+    /** Controlled open state, e.g. one field of a record open at a time. */
+    editing?: boolean;
+    /** Called when the field asks to open (`true`) or close (`false`). */
+    onEditingChange?: (editing: boolean) => void;
+    /** Controlled draft, e.g. to report unsaved input. Reset to `value` on open. */
+    draft?: T;
+    /** Called with every change of the draft, and with `value` when the field opens. */
+    onDraftChange?: (draft: T) => void;
+    /**
+     * Renders a failed save under the editor, in place of the message: a Try again button that
+     * calls `retry`, or a Reload latest after a version conflict.
+     */
+    renderError?: (error: unknown, context: InlineEditErrorContext<T>) => ReactNode;
+    /** Called on every change of `InlineEditState`. */
+    onStateChange?: (state: InlineEditState) => void;
     /** Each word defaults to `UixLabelsProvider` `inlineEdit`, then to English. */
     labels?: Partial<InlineEditLabels>;
     className?: string;
@@ -2784,9 +3487,12 @@ interface InlineEditProps {
  * A value that is edited in place (HAR-1381; TENSOR C16 `editable-record.tsx`): the value is
  * a button that says what it edits; activating it swaps in an editor with Save and Cancel.
  * Enter saves and Escape cancels; while `onSave` runs the editor is busy; a failed save keeps
- * the draft and shows why; afterwards focus is back on the value. Nothing is saved on blur.
+ * the draft and shows why; afterwards focus is back on the value, which shows what was saved
+ * until `value` catches up. HAR-1833: any value type (`equals`, `renderView`, `renderEditor`),
+ * saving on blur or on change (`commit`), controllable `editing` and `draft`, `renderError`
+ * with retry, `onStateChange`, an icon trigger, and a `readOnlyReason`.
  */
-declare function InlineEdit({ value, onSave, label, renderView, renderEditor, multiline, validate, placeholder, disabled, labels: labelOverrides, className, }: InlineEditProps): react.JSX.Element;
+declare function InlineEdit<T = string>({ value, onSave, label, renderView, renderEditor, multiline, validate, equals, isEmpty, commit, placeholder, disabled, readOnlyReason, trigger, editing: editingProp, onEditingChange, draft: draftProp, onDraftChange, renderError, onStateChange, labels: labelOverrides, className, }: InlineEditProps<T>): react.JSX.Element;
 
 /** The words of the "Discard changes?" step a `dirty` Drawer or Modal asks before it closes (HAR-2029). */
 interface DiscardPromptLabels {
@@ -2874,39 +3580,1542 @@ interface SearchBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onSubmit'
  */
 declare function SearchBar({ label, value: valueProp, defaultValue, onValueChange, onSubmit, onClear, placeholder, size, submitButton, submitVariant, landmark, inputDescribedBy, labels: labelsProp, name, inputId, inputRef, autoFocus, disabled, className, ...props }: SearchBarProps): 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;
+/** What `renderOverlay` receives (HAR-1826). */
+interface LightboxOverlayContext {
+    /** The item on show (0-based) and the item itself. */
+    index: number;
+    item: LightboxItem;
+    /** The rendered `<img>` or `<video>`; `naturalWidth` / `videoWidth` give the bitmap size. */
+    media: HTMLImageElement | HTMLVideoElement | null;
+    /**
+     * The overlay's size in CSS pixels. The overlay covers exactly the picture (not the letterbox
+     * around a fitted one), so a point at `(x, y)` in it is bitmap pixel
+     * `(x / width * naturalWidth, y / height * naturalHeight)`. 0 until the media has loaded.
+     */
+    width: number;
+    height: number;
+}
+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;
+    /**
+     * Buttons for the toolbar beside Close (HAR-1826), e.g. "Hide area" and "Undo" on a viewer
+     * that redacts a screenshot. Tab order: these, then Close. They sit inside the dialog.
+     */
+    actions?: ReactNode;
+    /**
+     * Content laid over the picture, in the picture's own box: it moves and scales with the
+     * fit / actual-size toggle. Pointer events on it never swipe or page, so it can draw. Each
+     * child positions itself (`position: absolute` in `%`, or px of `width` / `height`).
+     */
+    renderOverlay?: (context: LightboxOverlayContext) => ReactNode;
+    /**
+     * Runs first for every key in the viewer. Call `event.preventDefault()` to claim the key:
+     * the viewer then neither pages (arrows, Home, End) nor closes (Escape). For a draft that
+     * arrow keys move and Escape cancels.
+     */
+    onKeyDown?: (event: KeyboardEvent$1<HTMLDialogElement>) => void;
+    /** Escape only: `event.preventDefault()` keeps the viewer open. */
+    onEscapeKeyDown?: (event: KeyboardEvent$1<HTMLDialogElement>) => void;
+}
 /**
- * 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
- * provider; an explicit prop on one instance still wins.
- *
- * Client components read the provider. Server-renderable ones (`Pagination`, `BulkBar`)
- * cannot read context: pass `labels` from `useUixLabels()` in a client parent, or translate
- * on the server.
+ * 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 (not for a single item), 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. An annotating viewer (HAR-1826) adds toolbar `actions`, draws in
+ * `renderOverlay`, and claims Escape and the arrows with `onKeyDown` while a draft is open.
  */
-interface UixLabels {
-    modal?: {
-        close?: string;
-    };
-    drawer?: {
-        close?: string;
-    };
-    /** The "Discard changes?" step of a `dirty` Drawer or Modal (HAR-2029). */
-    discardPrompt?: Partial<DiscardPromptLabels>;
-    peek?: {
-        previous?: string;
-        next?: string;
-        close?: string;
-    };
-    toast?: {
-        dismiss?: string;
+declare function Lightbox({ items, index, onIndexChange, open, onClose, loop, labels: labelOverrides, className, actions, renderOverlay, onKeyDown: onKeyDownProp, onEscapeKeyDown, }: LightboxProps): react.JSX.Element;
+
+/** Every word `SortableList` renders or announces. `{label}` is the row's name. */
+interface SortableListLabels {
+    /** The drag grip's name. */
+    grip: string;
+    moveUp: string;
+    moveDown: string;
+    /** Polite announcement after a move: `{label}`, `{position}`, `{count}`. */
+    moved: string;
+}
+declare const DEFAULT_SORTABLE_LIST_LABELS: SortableListLabels;
+/** What `renderItem` receives besides the item. */
+interface SortableListItemContext {
+    index: number;
+    count: number;
+    /** This row is being dragged. */
+    dragging: boolean;
+}
+interface SortableListProps<T> extends Omit<HTMLAttributes<HTMLUListElement>, 'children' | 'onChange'> {
+    items: readonly T[];
+    getId: (item: T) => string;
+    /** The row's name in the grip, the move buttons and the announcement. Default: its id. */
+    getLabel?: (item: T) => string;
+    renderItem: (item: T, context: SortableListItemContext) => ReactNode;
+    /** Called with the full new order of ids after each keyboard move, and once when a drag ends. */
+    onReorder: (orderedIds: string[]) => void;
+    /** Rows show no grip and no move buttons. */
+    disabled?: boolean;
+    /** Each word defaults to `UixLabelsProvider` `sortableList`, then to English. */
+    labels?: Partial<SortableListLabels>;
+}
+/**
+ * A list the person reorders (HAR-1375; MOTUS C-16 photo order, TENSOR preset and start-page
+ * order): media, priorities, steps. Each row has a grip to drag with a pointer, and Move up /
+ * Move down buttons that are always there (a drag is never the only way). With focus anywhere
+ * in a row, Alt+↑ / Alt+↓ move it; a focused grip moves with ↑ / ↓ alone. Focus stays with the
+ * moved row, and a polite status says where it went. Keyboard moves are instant; a drag places
+ * the row under the pointer with no animation. Shares its order model with `ViewMenu`,
+ * `SavedViewMenu` and `NavFavourites`.
+ */
+declare function SortableList<T>({ items, getId, getLabel, renderItem, onReorder, disabled, labels: labelOverrides, className, ...props }: SortableListProps<T>): react.JSX.Element;
+
+type DiffKind = 'added' | 'removed' | 'changed' | 'conflicted';
+type DiffResolution = 'accept' | 'skip' | 'pending';
+interface DiffEntry {
+    path: string;
+    kind: DiffKind;
+    base?: JsonValue;
+    current?: JsonValue;
+    incoming?: JsonValue;
+}
+interface DiffSummary {
+    added: number;
+    removed: number;
+    changed: number;
+    conflicted: number;
+    resolved: number;
+    pending: number;
+}
+declare function buildThreeWayDiff(base: JsonValue | undefined, current: JsonValue | undefined, incoming: JsonValue | undefined, path?: string): DiffEntry[];
+declare function summarizeDiff(entries: DiffEntry[], resolutions?: Record<string, DiffResolution>): DiffSummary;
+
+/**
+ * Every word the diff viewer renders (TENSOR RX-125, UIX-12). `base` / `current` /
+ * `incoming` keep their meaning from before; `{path}`, `{version}`, `{resolved}` and
+ * `{total}` are placeholders.
+ *
+ * `acceptIncomingFor` / `keepCurrentFor` / `markPendingFor` are the accessible names of
+ * the three action buttons, so a screen reader hears which entry each one resolves. Keep
+ * the visible word inside the translated name (WCAG 2.5.3 Label in Name): speech-input
+ * users say what they see.
+ */
+interface DiffViewerLabels {
+    base: string;
+    current: string;
+    incoming: string;
+    region: string;
+    summary: string;
+    noDifferences: string;
+    noDifferencesDetail: string;
+    conflicted: string;
+    changed: string;
+    added: string;
+    removed: string;
+    resolved: string;
+    pending: string;
+    valueFor: string;
+    resolve: string;
+    acceptIncoming: string;
+    keepCurrent: string;
+    markPending: string;
+    acceptIncomingFor: string;
+    keepCurrentFor: string;
+    markPendingFor: string;
+    resolutionAccept: string;
+    resolutionSkip: string;
+    resolutionPending: string;
+    notPresent: string;
+    progress: string;
+}
+declare const DEFAULT_DIFF_VIEWER_LABELS: DiffViewerLabels;
+interface DiffViewerProps {
+    base?: JsonValue;
+    current?: JsonValue;
+    incoming?: JsonValue;
+    entries?: DiffEntry[];
+    resolutions?: Record<string, DiffResolution>;
+    onResolutionChange?: (path: string, resolution: DiffResolution) => void;
+    labels?: Partial<DiffViewerLabels>;
+    /**
+     * Height of the resolution buttons and the entry disclosure rows. `sm` (the default) is
+     * the compact 28px kit size; `md` follows `--uix-control-h`, so a theme that sets its
+     * own control height (for example 60px touch targets) gets it here too; `lg` is 44px.
+     */
+    controlSize?: 'sm' | 'md' | 'lg';
+    className?: string;
+    /**
+     * The name of an entry for people (HAR-1369): "First author" for `$.authors[0].name`. Shown
+     * instead of the path; a string also names the entry's regions and buttons (anything else
+     * leaves the path there). Default: the path.
+     */
+    labelFor?: (path: string) => ReactNode;
+    /**
+     * How a value shows: a name, a date, a chip, instead of `JSON.stringify`. `undefined` is a
+     * value that is not there in that version. Default: the JSON, or `labels.notPresent`.
+     */
+    renderValue?: (value: JsonValue | undefined, path: string, side: DiffSide) => ReactNode;
+    /** Where a version's value came from, shown under it ("Edited by Ana, 12 Oct"). Nothing for none. */
+    provenance?: (path: string, side: DiffSide) => ReactNode;
+}
+/** One of the three versions a `DiffViewer` entry compares. */
+type DiffSide = 'base' | 'current' | 'incoming';
+/**
+ * Three-way configuration diff with per-entry keyboard-operable resolution. For people who do
+ * not read JSON paths (HAR-1369, MOTUS B-A9): `labelFor` names an entry, `renderValue` shows a
+ * value as a name, a date or a chip, and `provenance` says where each version came from.
+ */
+declare function DiffViewer({ base, current, incoming, entries: providedEntries, resolutions: controlledResolutions, onResolutionChange, labels: labelOverrides, controlSize, className, labelFor, renderValue, provenance, }: DiffViewerProps): react.JSX.Element;
+
+interface MatchReviewField {
+    id: string;
+    label: string;
+    render?: (value: JsonValue | undefined, record: Record<string, JsonValue>) => ReactNode;
+}
+interface MatchReviewCandidate {
+    id: string;
+    record: Record<string, JsonValue>;
+    confidence?: number;
+    status?: 'pending' | 'resolved';
+    decision?: 'accepted' | 'dismissed' | 'split' | 'other';
+}
+type MatchReviewAction = 'accept' | 'dismiss' | 'split' | 'pick-other';
+interface MatchBulkResult {
+    succeeded: number;
+    failed?: number;
+}
+/**
+ * Every word the match review renders or announces (TENSOR RX-125, UIX-12). Plural
+ * pairs are `…One` / `…Many`; `{count}`, `{pending}`, `{total}`, `{id}` are placeholders.
+ */
+interface MatchReviewLabels {
+    region: string;
+    loading: string;
+    retry: string;
+    empty: string;
+    emptyDetail: string;
+    pendingOf: string;
+    bulk: string;
+    selectedCount: string;
+    applying: string;
+    acceptSelected: string;
+    dismissSelected: string;
+    caption: string;
+    select: string;
+    confidence: string;
+    status: string;
+    actions: string;
+    selectCandidate: string;
+    notScored: string;
+    resolved: string;
+    pending: string;
+    decisionAccepted: string;
+    decisionDismissed: string;
+    decisionSplit: string;
+    decisionOther: string;
+    accept: string;
+    dismiss: string;
+    split: string;
+    pickOther: string;
+    acceptingOne: string;
+    acceptingMany: string;
+    dismissingOne: string;
+    dismissingMany: string;
+    acceptedOne: string;
+    acceptedMany: string;
+    dismissedOne: string;
+    dismissedMany: string;
+    failedSuffix: string;
+    bulkAcceptFailed: string;
+    bulkDismissFailed: string;
+    /** Adopt mode (HAR-1369): a candidate's heading when `candidateLabel` gives none. `{id}`. */
+    candidate: string;
+    /** Adopt mode: the compare table's caption. `{candidate}`. */
+    compareCaption: string;
+    field: string;
+    /** Adopt mode: the column of the record as it is now. */
+    currentValue: string;
+    /** Adopt mode: the column of the candidate's values. */
+    candidateValue: string;
+    /** Adopt mode: the column of checkboxes. */
+    adopt: string;
+    /** Adopt mode: one checkbox's name. `{field}`, `{candidate}`. */
+    adoptField: string;
+    /** Adopt mode: shown instead of a checkbox when the candidate has the same value. */
+    same: string;
+    /** Adopt mode: the button with one field chosen. `{count}`. */
+    adoptSelectedOne: string;
+    /** Adopt mode: the button with any other number of fields chosen (0 too). `{count}`. */
+    adoptSelectedMany: string;
+    /** Adopt mode: the provenance disclosure. */
+    provenance: string;
+    /** Adopt mode: announced after `onAdopt` resolves, one field. `{count}`, `{candidate}`. */
+    adoptedOne: string;
+    /** Adopt mode: announced after `onAdopt` resolves, more fields. `{count}`, `{candidate}`. */
+    adoptedMany: string;
+    /** Adopt mode: shown when `onAdopt` rejects. */
+    adoptFailed: string;
+}
+declare const DEFAULT_MATCH_REVIEW_LABELS: MatchReviewLabels;
+interface MatchReviewProps {
+    incoming: Record<string, JsonValue>;
+    incomingLabel?: string;
+    fields: MatchReviewField[];
+    candidates: MatchReviewCandidate[];
+    selectedIds?: Set<string>;
+    onSelectionChange?: (ids: Set<string>) => void;
+    onDecision: (candidateId: string, action: MatchReviewAction) => void;
+    onBulkDecision?: (candidateIds: string[], action: Extract<MatchReviewAction, 'accept' | 'dismiss'>) => void | MatchBulkResult | Promise<void | MatchBulkResult>;
+    loading?: boolean;
+    error?: string;
+    onRetry?: () => void;
+    className?: string;
+    labels?: Partial<MatchReviewLabels>;
+    /**
+     * `decide` (default): one row per candidate, decided as a whole. `adopt` (HAR-1369, MOTUS B-A9
+     * registry candidates): per candidate a table of the record now against the candidate, field
+     * by field, a checkbox per field that differs, and an Adopt button that calls `onAdopt`.
+     */
+    fieldMode?: 'decide' | 'adopt';
+    /** Adopt mode: take the chosen fields from the candidate. A promise keeps the button busy until it settles. */
+    onAdopt?: (candidateId: string, fieldIds: string[]) => void | Promise<unknown>;
+    /** Adopt mode: the candidate's heading, e.g. its source ("DNB", "Wikidata"). Default `labels.candidate`. */
+    candidateLabel?: (candidate: MatchReviewCandidate) => ReactNode;
+    /** Adopt mode: where a candidate comes from, in a disclosure under its table (source, retrieved, match reason). */
+    provenance?: (candidate: MatchReviewCandidate) => ReactNode;
+}
+/** Generic descriptor-driven incoming-record to candidate-match decision surface. */
+declare function MatchReview({ incoming, incomingLabel, fields, candidates, selectedIds, onSelectionChange, onDecision, onBulkDecision, loading, error, onRetry, className, labels: labelOverrides, fieldMode, onAdopt, candidateLabel, provenance, }: MatchReviewProps): react.JSX.Element;
+
+/**
+ * A QR Code encoder (ISO/IEC 18004) for `QrCode` (HAR-1251): byte mode (UTF-8), the four
+ * error-correction levels, versions 1 to 40, all eight masks scored by the standard's
+ * penalty rules. Pure and dependency-free, so a consumer never pulls a QR library in for a
+ * poster or a voucher. `qr-model.test.mjs` decodes its output with a reference decoder.
+ *
+ * The algorithm follows the standard's own construction (function patterns, Reed-Solomon over
+ * GF(256) with 0x11D, zig-zag placement, BCH-coded format and version information).
+ */
+/** How much of the symbol can be lost and still read: about 7, 15, 25 and 30 % of codewords. */
+type QrErrorCorrection = 'L' | 'M' | 'Q' | 'H';
+interface QrMatrix {
+    /** 1 to 40. Each version is 4 modules wider than the one before (version 1 is 21 × 21). */
+    version: number;
+    /** Modules per side, without the quiet zone. */
+    size: number;
+    errorCorrection: QrErrorCorrection;
+    /** The mask the penalty rules chose, 0 to 7. */
+    mask: number;
+    /** `modules[y][x]` is true for a dark module. */
+    modules: boolean[][];
+}
+interface QrEncodeOptions {
+    /** Default `M`: survives a crease or a smudge on a printed poster. */
+    errorCorrection?: QrErrorCorrection;
+    /**
+     * The smallest version to use (1 to 40); a larger one is chosen when the text needs it. A
+     * value that is not a finite number throws a `RangeError` (it is a mistake, not a long text).
+     */
+    minVersion?: number;
+    /**
+     * Mark text with characters beyond ASCII as UTF-8 with an ECI 26 designator (12 bits before
+     * the data). Off by default: most scanners read UTF-8 without it and a few old ones misread a
+     * symbol that has one; turn it on for a scanner that assumes ISO 8859-1 otherwise.
+     */
+    eci?: boolean;
+    /** Force a mask (0 to 7) instead of the lowest-penalty one; for tests. */
+    mask?: number;
+}
+/** Thrown when the text does not fit in version 40 at the requested level. */
+declare class QrCapacityError extends Error {
+    readonly bytes: number;
+    readonly errorCorrection: QrErrorCorrection;
+    constructor(bytes: number, errorCorrection: QrErrorCorrection);
+}
+/** Data codewords (bytes) a version holds at a level. */
+declare function qrDataCapacity(version: number, errorCorrection: QrErrorCorrection): number;
+/**
+ * The smallest version that holds `bytes` bytes at a level, or undefined past version 40.
+ * `headerBits` counts bits before the byte segment (12 for an ECI designator).
+ */
+declare function qrVersionFor(bytes: number, errorCorrection: QrErrorCorrection, minVersion?: number, headerBits?: number): number | undefined;
+/**
+ * Encodes `text` (as UTF-8 bytes) into a QR matrix: the smallest version that fits at the
+ * level, the mask with the lowest penalty. Throws `QrCapacityError` past version 40
+ * (2,953 bytes at L, 1,273 at H).
+ */
+declare function encodeQr(text: string, options?: QrEncodeOptions): QrMatrix;
+/**
+ * The dark modules as one SVG path in module units, offset by `margin` (the quiet zone):
+ * one `h`-run per stretch of dark modules in a row, so a version-10 symbol is one short path.
+ */
+declare function qrPath(matrix: QrMatrix, margin?: number): string;
+
+/** The words of a `QrCode` (HAR-1251). */
+interface QrCodeLabels {
+    /** Shown in place of the symbol when `value` does not fit in a QR code at the chosen level. */
+    tooLong: string;
+}
+/** The English words of `QrCode`, the base `UixLabelsProvider` `qrCode` and `labels` override. */
+declare const DEFAULT_QR_CODE_LABELS: QrCodeLabels;
+interface QrCodeProps extends Omit<SVGAttributes<SVGSVGElement>, 'children' | 'width' | 'height' | 'viewBox'> {
+    /** The text to encode, e.g. the campaign URL. Encoded as UTF-8 bytes. */
+    value: string;
+    /**
+     * The symbol's accessible name, e.g. "QR code: open the summer campaign". Say where it leads;
+     * the image itself tells a screen-reader user nothing.
+     */
+    label: string;
+    /**
+     * `L` 7 %, `M` 15 % (default), `Q` 25 %, `H` 30 % of the symbol may be lost and still read.
+     * Use `Q` or `H` for a poster that may be creased, scuffed or partly covered.
+     */
+    errorCorrection?: QrErrorCorrection;
+    /**
+     * The rendered width and height, quiet zone included: a number of CSS pixels (default 160) or
+     * any CSS length (`'32mm'` on paper). Keep at least 2 px per module on a screen and 0.4 mm per
+     * module on paper: a 30-character URL at `M` is version 3, 37 modules with the quiet zone, so
+     * at least 74 px or 15 mm.
+     */
+    size?: number | string;
+    /** The smallest version to use, so a set of posters gets symbols of one size. */
+    minVersion?: number;
+    /** Mark non-ASCII text as UTF-8 with an ECI designator (see `QrEncodeOptions.eci`). Default false. */
+    eci?: boolean;
+    /** The words. Default: `UixLabelsProvider` `qrCode`, then English. */
+    labels?: Partial<QrCodeLabels>;
+}
+/**
+ * A scannable, print-safe QR code (HAR-1251; SHOPx PRE-01 poster, voucher): `value` as an SVG
+ * with the standard four-module quiet zone, dark modules on light paper in every theme, in print
+ * and in forced colours (scanners read dark on light; an inverted symbol fails many of them).
+ * The encoder is the kit's own (`encodeQr`), so nothing is fetched and no library is added.
+ */
+declare function QrCode({ value, label, errorCorrection, size, minVersion, eci, labels: labelsProp, className, style, ...props }: QrCodeProps): react.JSX.Element;
+
+/** The words of a `CodeDisplay` (HAR-1253). */
+interface CodeDisplayLabels {
+    /** The live countdown; `{time}` is `m:ss` (or `h:mm:ss`). */
+    expiresIn: string;
+    /** Announced once when `warnBefore` seconds are left; `{time}` is that time as `m:ss`. */
+    expiresSoon: string;
+    /** Shown, and announced once, when the code has expired. Text, so the state never rests on colour. */
+    expired: string;
+    /** The copy button's accessible name. */
+    copy: string;
+    /** Announced after a copy. */
+    copied: string;
+    /** Announced when the copy failed. */
+    copyFailed: string;
+}
+declare const DEFAULT_CODE_DISPLAY_LABELS: CodeDisplayLabels;
+interface CodeDisplayProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /**
+     * The code, e.g. `"K7Q4PX9MW"` or `"K7Q-4PX-9MW"`. A code that already contains spaces or
+     * hyphens is shown in those groups; otherwise it is cut into groups of `groupSize`.
+     */
+    code: string;
+    /** The visible name above the code, e.g. "Pairing code"; it also names the group. */
+    label: ReactNode;
+    /** Characters per group, or the length of each group in turn (`[4, 4, 4]`). Default 3. */
+    groupSize?: number | readonly number[];
+    /** Drawn between groups, never read out. Default `-`. */
+    separator?: string;
+    /** `md` (default) for a panel; `lg` for a code read across a counter. */
+    size?: 'md' | 'lg';
+    /** When the code stops working (an ISO instant, epoch milliseconds or a Date): shows a countdown, then the expired state. */
+    expiresAt?: string | number | Date;
+    /**
+     * Seconds before expiry when the countdown turns to a warning and a screen reader hears it
+     * once (`labels.expiresSoon`). Default 60; 0 turns the warning off.
+     */
+    warnBefore?: number;
+    /** Called once when the countdown reaches zero while the component is on screen. */
+    onExpire?: () => void;
+    /** Adds a copy button while the code is live. */
+    copyable?: boolean;
+    /**
+     * What a screen reader says for one character. Default: the character itself, so "K7Q" is
+     * read "K, 7, Q". Use it for a spelling alphabet or to tell O from 0.
+     */
+    spell?: (character: string) => string;
+    /** The words. Default: `UixLabelsProvider` `codeDisplay`, then English. */
+    labels?: Partial<CodeDisplayLabels>;
+}
+/** The code in its display groups. */
+declare function codeGroups(code: string, groupSize?: number | readonly number[]): string[];
+/** `m:ss`, or `h:mm:ss` from an hour up, for a number of whole seconds. */
+declare function formatCountdown(seconds: number): string;
+/**
+ * A one-time code shown large (HAR-1253; SHOPx PRE-08 till pairing, the shopper's voucher):
+ * monospace characters in groups, spelled character by character to a screen reader, an
+ * optional countdown that ends in an expired state said in words, and an optional copy button.
+ * The consumer makes the code and enforces its expiry; this only shows it.
+ */
+declare function CodeDisplay({ code, label, groupSize, separator, size, expiresAt, warnBefore, onExpire, copyable, spell, labels: labelsProp, className, ...props }: CodeDisplayProps): react.JSX.Element;
+
+/** The words of a `ContactCard` (HAR-1379). */
+interface ContactCardLabels {
+    /** The email action's visible text. */
+    email: string;
+    /** The phone action's visible text. */
+    call: string;
+    /** The email action's accessible name; `{name}` is the contact's name. Starts with the visible text (WCAG 2.5.3). */
+    emailName: string;
+    /** The phone action's accessible name; `{name}`. */
+    callName: string;
+    /** Shown in place of the name when the person's data was erased and no name is left. */
+    purgedName: string;
+    /** The line under the name of an erased contact. */
+    purged: string;
+    /** The line under the name of a contact whose details cannot be shown (no access, or not loaded). */
+    unavailable: string;
+}
+declare const DEFAULT_CONTACT_CARD_LABELS: ContactCardLabels;
+/**
+ * `active` shows everything given. `purged`: the person's data was erased; a neutral
+ * placeholder, no details and no actions. `unavailable`: the name stays, the details and actions
+ * do not (no access, or they could not be loaded).
+ */
+type ContactCardState = 'active' | 'purged' | 'unavailable';
+interface ContactCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'role'> {
+    /** The person's or the organisation's name. Leave it out for an erased contact. */
+    name?: string;
+    /** Role or relation, e.g. "Practice manager · Dom zdravlja Centar". */
+    role?: ReactNode;
+    /** An `Avatar` (size `lg` reads best). An erased contact always gets the placeholder. */
+    avatar?: ReactNode;
+    /** Shown as text and offered as a `mailto:` action. */
+    email?: string;
+    /** Shown as written and offered as a `tel:` action (spaces, dashes and brackets are dropped from the link). */
+    phone?: string;
+    /** More actions after Email and Call, e.g. a `ButtonLink` to the record. */
+    actions?: ReactNode;
+    /** Figures under the role (`.uix-contact__stats`). */
+    stats?: ReactNode;
+    /** The name as a link to the person's record. */
+    href?: string;
+    /** Your router's link for `href`. */
+    renderLink?: UixRenderLink;
+    /** The element of the name: a heading when the card stands for a section. Default `div`. */
+    nameAs?: 'h2' | 'h3' | 'h4' | 'div';
+    state?: ContactCardState;
+    /** Without the card frame, for a peek, a popover or a sidebar that is already a surface. */
+    bare?: boolean;
+    /** The words. Default: `UixLabelsProvider` `contactCard`, then English. */
+    labels?: Partial<ContactCardLabels>;
+}
+/** The digits and a leading + of a phone number, for a `tel:` link. */
+declare const telHref: (phone: string) => string;
+/**
+ * A person or an organisation at a glance (HAR-1379; MOTUS C-15, TENSOR incident people card):
+ * avatar, name, role, the email address and phone number as text, and Email / Call actions as
+ * `mailto:` / `tel:` links. An erased contact (`state="purged"`) shows a neutral placeholder
+ * and no way to reach anyone, so a purge is never undone on screen by a stale address.
+ */
+declare function ContactCard({ name, role, avatar, email, phone, actions, stats, href, renderLink, nameAs: NameTag, state, bare, labels: labelsProp, className, ...props }: ContactCardProps): react.JSX.Element;
+
+/** The words of `PrintSignature` (HAR-986). */
+interface PrintLayoutLabels {
+    /** The caption under the signature line. */
+    signature: string;
+    /** The caption of the stamp box. */
+    stamp: string;
+}
+declare const DEFAULT_PRINT_LAYOUT_LABELS: PrintLayoutLabels;
+type PrintPageSize = 'A4' | 'A5';
+interface PrintLayoutProps extends HTMLAttributes<HTMLDivElement> {
+    /** The paper. Default `A4` (210 × 297 mm); `A5` is 148 × 210 mm (a poster, a slip). */
+    size?: PrintPageSize;
+    /** Default `portrait`. */
+    orientation?: 'portrait' | 'landscape';
+    /** Repeats at the top of every printed page: the practice or store identity. */
+    header?: ReactNode;
+    /** Repeats at the foot of every printed page, before the page number. */
+    footer?: ReactNode;
+    /** "page / pages" in the bottom-right page margin of every printed page. Default `true`; never on a `singlePage` layout. */
+    pageNumbers?: boolean;
+    /**
+     * One page and no more (a poster, a one-page readout): the header and footer are not
+     * repeated, the layout is kept in one piece, and the screen preview is exactly one page tall.
+     * When the content does not fit, the preview is outlined and `onOverflowChange(true)` is called,
+     * so the product can shorten it before anyone prints.
+     */
+    singlePage?: boolean;
+    /** Called with `true` when a `singlePage` layout's content is taller than its page, and `false` once it fits again. */
+    onOverflowChange?: (overflowing: boolean) => void;
+    /**
+     * When printing, show only print layouts: everything else on the page (the app shell, the
+     * toolbar with the Print button, toasts, dialogs) is hidden. Default `true`.
+     */
+    isolate?: boolean;
+}
+/**
+ * A print document frame (HAR-986, HAR-1252; MEDx S20 "Nalaz i mišljenje" and the day list,
+ * SHOPx PRE-01 A5 poster and SHOP-03 one-page readout): an A4 or A5 page with the paper's margins,
+ * a header and a footer that repeat on every printed page, page numbers in the page margin, and
+ * black-on-white tokens for everything inside, on screen (as a paper preview) and on paper. The
+ * consumer supplies the sections; the browser's own print (`window.print()`) makes the pages.
+ */
+declare function PrintLayout({ size, orientation, header, footer, pageNumbers, singlePage, onOverflowChange, isolate, className, children, style, ...props }: PrintLayoutProps): react.JSX.Element;
+interface PrintSignatureProps extends HTMLAttributes<HTMLDivElement> {
+    /** The caption under the line. Default `labels.signature`. */
+    label?: ReactNode;
+    /** The signer's printed name and title under the caption, e.g. "dr. Amra Hadžić, spec. pedijatrije". */
+    name?: ReactNode;
+    /** Place and date at the start of the block, e.g. "Sarajevo, 22. 10. 2026.". */
+    placeAndDate?: ReactNode;
+    /** A box for the stamp beside the signature. */
+    stamp?: boolean;
+    labels?: Partial<PrintLayoutLabels>;
+}
+/** A signature line (and an optional stamp box) that is never split across two pages. */
+declare function PrintSignature({ label, name, placeAndDate, stamp, labels: labelsProp, className, ...props }: PrintSignatureProps): react.JSX.Element;
+/** Starts a new printed page here. On screen it is a dashed line, so the preview shows where the page ends. */
+declare function PrintPageBreak({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+/** The words of a `QrScanner` (HAR-1254). */
+interface QrScannerLabels {
+    /** The viewfinder region's name. */
+    viewfinder: string;
+    /** Starts the camera (the browser asks for permission after it). */
+    start: string;
+    /** Stops the camera. */
+    stop: string;
+    /** While the browser's permission prompt is open. */
+    asking: string;
+    /** While the camera runs and nothing was read yet. */
+    scanning: string;
+    /** Camera access was refused. */
+    deniedTitle: string;
+    /** How to allow it again: the browser keeps the refusal until the person changes it. */
+    deniedBody: string;
+    /** No camera API (an old browser, or a page not served over HTTPS). */
+    unsupportedTitle: string;
+    unsupportedBody: string;
+    /** No camera found, or it is in use by another app. */
+    noCameraTitle: string;
+    noCameraBody: string;
+    /** The camera started but sends no picture. */
+    noFrameTitle: string;
+    noFrameBody: string;
+    /** Shown after `hintAfter` ms of frames without a code. */
+    unreadable: string;
+    /** Tries the camera again. */
+    retry: string;
+    /** The torch toggle's name. */
+    torch: string;
+    /** Announced once when a code was read; `{value}` is the text. */
+    read: string;
+}
+declare const DEFAULT_QR_SCANNER_LABELS: QrScannerLabels;
+/**
+ * What the scanner is doing. `idle` shows the explainer and the start button; `asking` waits for
+ * the browser's prompt; `scanning` shows the picture; `denied`, `unsupported`, `no-camera` and
+ * `no-frame` say what went wrong and how to go on.
+ */
+type QrScannerStatus = 'idle' | 'asking' | 'scanning' | 'denied' | 'unsupported' | 'no-camera' | 'no-frame';
+/** One camera frame for the consumer's decoder. It never leaves the device unless the decoder sends it. */
+interface QrScannerFrame {
+    /** The frame's pixels, at most `maxFrameSize` on the long side. */
+    imageData: ImageData;
+    /** The live video element, for a decoder that reads it directly (`BarcodeDetector.detect(video)`). */
+    video: HTMLVideoElement;
+}
+/** Returns the text it read, or nothing. Throwing counts as nothing read. */
+type QrScannerDecoder = (frame: QrScannerFrame) => string | null | undefined | Promise<string | null | undefined>;
+interface QrScannerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onError'> {
+    /** Your decoder (a WASM or JS QR reader, or `BarcodeDetector`). The kit ships none and calls it with frames only. */
+    decode: QrScannerDecoder;
+    /** Called with each new text read. The same text again is ignored for `repeatAfter` ms. */
+    onResult: (value: string) => void;
+    /** Why the page wants the camera, shown before the browser's own prompt (and after a refusal). */
+    explainer?: ReactNode;
+    /** The manual entry (a field and a button): always rendered, in every state, after the viewfinder. */
+    manualEntry?: ReactNode;
+    /**
+     * Starts the camera without the start button when the browser says permission was already
+     * given (`navigator.permissions`). Default `true`; the explainer is still shown first otherwise.
+     */
+    autoStart?: boolean;
+    /** Called on every status change, e.g. to log it or to move focus to the manual field after a refusal. */
+    onStatusChange?: (status: QrScannerStatus) => void;
+    /** Milliseconds between decode attempts. Default 200. */
+    interval?: number;
+    /** The long side of the frame handed to the decoder, in pixels. Default 640. */
+    maxFrameSize?: number;
+    /** The same text read again within this many milliseconds is not reported twice. Default 2000. */
+    repeatAfter?: number;
+    /** Milliseconds of frames without a code before the "still nothing read" hint. Default 8000. */
+    hintAfter?: number;
+    /** Milliseconds after the camera started without a single frame before `no-frame`. Default 5000. */
+    frameTimeout?: number;
+    /** `environment` (default, the back camera) or `user`. */
+    facingMode?: 'environment' | 'user';
+    /** The words. Default: `UixLabelsProvider` `qrScanner`, then English. */
+    labels?: Partial<QrScannerLabels>;
+}
+/**
+ * A camera viewfinder that reads QR codes with a decoder the product supplies (HAR-1254; SHOPx
+ * SHOP-07 receipt scan, SHOP-09 till; MOTUS circulation intake). It explains why it wants the
+ * camera before the browser asks, says plainly when access is blocked, missing or unsupported
+ * and how to go on, and always keeps the manual entry next to it. Frames go to `decode` and
+ * nowhere else: the component makes no network request. The camera stops on unmount, on Stop
+ * and while the page is hidden.
+ */
+declare function QrScanner({ decode, onResult, explainer, manualEntry, autoStart, onStatusChange, interval, maxFrameSize, repeatAfter, hintAfter, frameTimeout, facingMode, labels: labelsProp, className, ...props }: QrScannerProps): react.JSX.Element;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /**
+     * `sm` 28 px, `md` 36 px (default), `lg` 44 px: the touch-target floor of a public page, the
+     * same height as `Button size="lg"` (HAR-1812).
+     */
+    size?: 'sm' | 'md' | 'lg';
+    invalid?: boolean;
+    valid?: boolean;
+    /**
+     * "Check this": a value the reader should confirm, not an error, e.g. one an assistant filled
+     * in (HAR-1814). Draws the warning border; `invalid` wins when both are set.
+     */
+    warning?: boolean;
+}
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+interface InputGroupProps {
+    children: ReactNode;
+    leadingIcon?: ReactNode;
+    trailingIcon?: ReactNode;
+    /**
+     * A control at the end of the field, inside its border: a reveal toggle, a clear or a copy
+     * button (HAR-1376). Give it the class `uix-input-group__action` (an icon button sized to the
+     * field) and an accessible name. It takes the place of `trailingIcon`.
+     */
+    trailingAction?: ReactNode;
+    className?: string;
+    /** Injected by `<Field>` when it wraps the group; forwarded onto the child control. */
+    id?: string;
+    'aria-describedby'?: string;
+    'aria-invalid'?: AriaAttributes['aria-invalid'];
+    'aria-required'?: AriaAttributes['aria-required'];
+}
+/**
+ * Icon-adorned wrapper for a child `<Input>`. The control is passed as `children`, so
+ * `<Field>`'s injected `id`/`aria-*` land on this wrapper — they're forwarded onto the
+ * single child element (the child's own props win) so label/message association survives
+ * the extra div (UIX-A11Y-3).
+ */
+declare function InputGroup({ children, leadingIcon, trailingIcon, trailingAction, className, id, 'aria-describedby': describedBy, 'aria-invalid': invalid, 'aria-required': required, }: InputGroupProps): react.JSX.Element;
+
+/** The words `PasswordInput` renders. */
+interface PasswordInputLabels {
+    /**
+     * Name of the reveal toggle. It stays the same while the password shows: the toggle's pressed
+     * state (`aria-pressed`) says whether it is on.
+     */
+    show: string;
+}
+declare const DEFAULT_PASSWORD_INPUT_LABELS: PasswordInputLabels;
+interface PasswordInputProps extends Omit<InputProps, 'type'> {
+    /** Controlled: whether the password shows as text. */
+    revealed?: boolean;
+    /** Uncontrolled: shown as text at first. Default `false`. */
+    defaultRevealed?: boolean;
+    onRevealedChange?: (revealed: boolean) => void;
+    /** Each word defaults to `UixLabelsProvider` `passwordInput`, then to English. */
+    labels?: Partial<PasswordInputLabels>;
+    /** Class of the wrapping `InputGroup` (`className` goes on the input). */
+    groupClassName?: string;
+}
+/**
+ * A password field with a reveal toggle (HAR-1376): an `Input type="password"` and, inside its end,
+ * a toggle button (`aria-pressed`) that shows the password as text and hides it again. A pointer
+ * press leaves focus in the field; the keyboard reaches the toggle with Tab. The password is
+ * hidden again when its form submits, so a password manager sees a password field. `autoComplete`
+ * passes through (`current-password`, `new-password`); inside `Field` the label, hint and error
+ * land on the input. `ref` is the input.
+ */
+declare const PasswordInput: react.ForwardRefExoticComponent<PasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+
+/** Every word `TagInput` renders or announces. */
+interface TagInputLabels {
+    /** Name of a chip's × button; `{tag}`. */
+    remove: string;
+    /** Announced after a tag was added; `{tag}`. */
+    added: string;
+    /** Announced after a tag was removed; `{tag}`. */
+    removed: string;
+    /** Shown when the tag is already there; `{tag}`. */
+    duplicate: string;
+    /** Shown when `maxTags` are there; `{max}`. */
+    max: string;
+    /** Name of the suggestion list. */
+    suggestions: string;
+    /** Name of the list of chips. */
+    list: string;
+    /** Part of the field's description: how many tags there are; `{count}`. */
+    count: string;
+}
+declare const DEFAULT_TAG_INPUT_LABELS: TagInputLabels;
+interface TagInputProps {
+    /** The tags, in order. */
+    value: readonly string[];
+    onValueChange: (value: string[]) => void;
+    /** Offered while typing (those already added are left out); ArrowDown reaches them. */
+    suggestions?: readonly string[];
+    /**
+     * Check a tag before it is added: return a message to refuse it (shown under the field), or
+     * `null` to accept it. Runs after the duplicate and `maxTags` checks.
+     */
+    validate?: (tag: string, value: readonly string[]) => string | null | undefined;
+    /** The most tags; past it, adding is refused with the `max` message. */
+    maxTags?: number;
+    /** Keys that add the typed text. Default Enter and comma. */
+    separators?: readonly string[];
+    /** Submits each tag as its own value under this name (hidden inputs). */
+    name?: string;
+    /** Lands on the text input, so a `<label htmlFor>` or `<Field>` names it. */
+    id?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+    'aria-invalid'?: AriaAttributes['aria-invalid'];
+    'aria-required'?: AriaAttributes['aria-required'];
+    /** Translatable words; English defaults in {@link DEFAULT_TAG_INPUT_LABELS}. */
+    labels?: Partial<TagInputLabels>;
+    className?: string;
+}
+/**
+ * Several short tags in one field (HAR-1377): type and press Enter (or a comma) to add a chip;
+ * pasting "a, b, c" adds three. A duplicate (ignoring case and accents), a refusal from `validate`
+ * or one past `maxTags` keeps the text and says why. Suggestions open under the field as a
+ * top-layer list once the person types (or presses ArrowDown): ArrowDown / ArrowUp move, Enter adds
+ * the active one, Escape closes it. Backspace in the empty field
+ * goes to the last chip; ArrowLeft / ArrowRight move between chips and back to the field;
+ * Backspace or Delete on a chip removes it. Each change is announced politely. Works in `Field`
+ * (the text input gets the label, hint and error) and submits each tag under `name`.
+ */
+declare function TagInput({ value, onValueChange, suggestions, validate, maxTags, separators, name, id: idProp, placeholder, disabled, invalid, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, 'aria-required': ariaRequired, labels: labelOverrides, className, }: TagInputProps): react.JSX.Element;
+
+/** Presence of a person (HAR-1374). Each state has its own shape as well as its own colour. */
+type AvatarPresence = 'online' | 'busy' | 'away' | 'offline';
+/** The words read for each presence state. English; pass translations as `presenceLabels`. */
+declare const DEFAULT_PRESENCE_LABELS: Record<AvatarPresence, string>;
+interface AvatarProps extends HTMLAttributes<HTMLSpanElement> {
+    /** TENSOR RX-125 (UIX-04): translatable; English default. Still honoured for `online`. */
+    onlineLabel?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    src?: string;
+    alt?: string;
+    /** Initials / fallback shown when there is no `src`. */
+    children?: ReactNode;
+    /** Online status dot. The same as `presence="online"`; kept for existing callers. */
+    status?: boolean;
+    /**
+     * A presence dot: `online` (filled green), `busy` (red with a bar), `away` (an amber ring),
+     * `offline` (a grey ring). The state is also in visually hidden text, so it is never colour
+     * alone.
+     */
+    presence?: AvatarPresence;
+    /** Translations of the presence words. */
+    presenceLabels?: Partial<Record<AvatarPresence, string>>;
+}
+/** Avatar over `.uix-avatar`. Renders an image when `src` is set, else children (initials). */
+declare function Avatar({ size, src, alt, children, status, presence, presenceLabels, onlineLabel, className, ...props }: AvatarProps): react.JSX.Element;
+interface PresenceDotProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    presence: AvatarPresence;
+    /**
+     * The state in words for assistive technology. Default: the English word. Pass `null` when
+     * the state is already written next to the dot, to make the dot decorative.
+     */
+    label?: string | null;
+}
+/** The presence dot on its own, for a row or a menu that shows no avatar (HAR-1374). */
+declare function PresenceDot({ presence, label, className, ...props }: PresenceDotProps): react.JSX.Element;
+interface AvatarGroupProps extends HTMLAttributes<HTMLSpanElement> {
+    children?: ReactNode;
+}
+/** Overlapping avatar stack over `.uix-avatar-group`. */
+declare function AvatarGroup({ children, className, ...props }: AvatarGroupProps): react.JSX.Element;
+interface UserChipProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Usually an `<Avatar />`. */
+    avatar?: ReactNode;
+    name?: ReactNode;
+    /** Secondary line (role, email). */
+    sub?: ReactNode;
+}
+/** Avatar + name (+ optional sub-line) over `.uix-user-chip`. */
+declare function UserChip({ avatar, name, sub, className, children, ...props }: UserChipProps): react.JSX.Element;
+
+interface AccountMenuUser {
+    /** The person's name, shown on the trigger and used for the avatar's initials. */
+    name: string;
+    /** A second line: an email, a role, a branch. */
+    sub?: ReactNode;
+    /** A photo URL, or your own avatar content. Without it the avatar shows the initials. */
+    avatar?: string | ReactNode;
+    /** A presence dot on the avatar (`online`, `busy`, `away`, `offline`). */
+    status?: AvatarPresence;
+}
+interface AccountMenuLabels {
+    /** The menu's name (`aria-label` of the list). Default "Account". */
+    menu: string;
+}
+declare const DEFAULT_ACCOUNT_MENU_LABELS: AccountMenuLabels;
+interface AccountMenuProps {
+    user: AccountMenuUser;
+    /**
+     * The menu's rows: `MenuItem` (profile, preferences, sign out with `tone="danger"`),
+     * `MenuRadioGroup` for a presence choice, `MenuSeparator`.
+     */
+    items?: ReactNode;
+    /**
+     * The rail form: the trigger shows the avatar only; the name stays the button's accessible
+     * name. Pair it with `Sidebar nav="rail"`.
+     */
+    collapsed?: boolean;
+    /** Where the menu opens. Default `top-start`: the trigger usually sits at the bottom of a sidebar. */
+    placement?: Placement;
+    labels?: Partial<AccountMenuLabels>;
+    /** The spoken presence words (after the name and second line), e.g. `{ online: 'Dostupan' }`. */
+    presenceLabels?: Partial<Record<AvatarPresence, string>>;
+    className?: string;
+}
+/** Up to two initials from a name, first and last word: "Ada Lovelace" → "AL", "Dževad Hodžić" → "DH". */
+declare function accountInitials(name: string): string;
+declare function AccountMenu({ user, items, collapsed, placement, labels: labelOverrides, presenceLabels, className }: AccountMenuProps): react.JSX.Element;
+
+type PillTone = 'neutral' | 'success' | 'info' | 'warning' | 'danger' | 'critical' | 'muted' | 'progress' | 'attention' | 'overdue' | 'sla-ok' | 'sla-at-risk' | 'sla-breached' | 'p1' | 'p2' | 'p3' | 'p4' | 'p5';
+/**
+ * How loud the pill is (HAR-1563). `soft` (default) is the tinted wash; `filled` is its old name
+ * and still works. `dot` is the quiet one for tables: no fill, a neutral label and a coloured dot.
+ * `outline` is a neutral hairline with a hushed label and a dot; only `critical` keeps a toned
+ * border.
+ */
+type PillTreatment = 'soft' | 'filled' | 'dot' | 'outline';
+type PillSize = 'sm' | 'md' | 'lg';
+interface StatusPillProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: PillTone;
+    /**
+     * `soft` (default; `filled` is an alias) = tinted wash; `dot` = a coloured dot beside a neutral
+     * label, for dense tables; `outline` = a neutral hairline, a hushed label and a dot. `dot` and
+     * `outline` always draw the dot.
+     */
+    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;
+    /** Draws the tone's dot before the label. Always on for the `dot` and `outline` treatments. */
+    dot?: boolean;
+    children?: ReactNode;
+}
+declare function StatusPill({ tone, treatment, size, dot, children, className, ...props }: StatusPillProps): react.JSX.Element;
+
+/** One entry of an access or change history. The consumer supplies it free of personal health data. */
+interface AuditLogEvent {
+    id: string;
+    /** Who did it: a name, or a node (an avatar and a name). */
+    actor: ReactNode;
+    /** What they did: a key of `actions`. */
+    action: string;
+    /** What it was done to: "Patient record 1042", "Invoice R-2026-118". */
+    target?: ReactNode;
+    /**
+     * When: a `Date`, epoch ms or an ISO string. An ISO date-time without an offset
+     * (`2026-10-22T09:30:00`) is read as UTC, as audit stores keep it, not as the viewer's local time.
+     */
+    at: Date | number | string;
+    /** More about it, behind a Details disclosure: fields changed, the reason given, the IP. */
+    detail?: ReactNode;
+}
+/** How an action reads and looks; the consumer labels its own action enum. */
+interface AuditLogAction {
+    label: string;
+    tone?: StatusPillProps['tone'];
+}
+/** The filters the person chose: `when` (a date range), `actor` and `action` (sets of ids). */
+interface AuditLogFilters {
+    when?: Extract<FilterValue, {
+        kind: 'date-range';
+    }>;
+    actor?: Extract<FilterValue, {
+        kind: 'enum';
+    }>;
+    action?: Extract<FilterValue, {
+        kind: 'enum';
+    }>;
+}
+interface AuditLogLabels {
+    /** Names the list. */
+    list: string;
+    /** Names the filter group. */
+    filters: string;
+    when: string;
+    actor: string;
+    action: string;
+    clearFilters: string;
+    details: string;
+    loadMore: string;
+    /** Polite status while more entries load. */
+    loadingMore: string;
+    /** Polite status after more entries arrived. `{count}`. */
+    loaded: string;
+    /** Shown (as an alert) when `loadMoreError` is set; the Show older entries button retries. */
+    loadMoreFailed: string;
+    loading: string;
+    empty: string;
+    emptyDetail: string;
+    filteredEmpty: string;
+    filteredEmptyDetail: string;
+    error: string;
+    retry: string;
+    forbidden: string;
+    forbiddenDetail: string;
+}
+declare const DEFAULT_AUDIT_LOG_LABELS: AuditLogLabels;
+interface AuditLogProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    events: readonly AuditLogEvent[];
+    /** Every action the log can show, by key: its label and the tone of its pill. */
+    actions: Readonly<Record<string, AuditLogAction>>;
+    /**
+     * `ready` (default), `loading` (the first load: skeleton rows), `error`, or `forbidden`.
+     * A reload with rows on show is `refreshing`, not `loading`.
+     */
+    status?: 'ready' | 'loading' | 'error' | 'forbidden';
+    /**
+     * A reload is running (the filters changed): the rows on show stay in a `BusyRegion`, busy at
+     * once, dimmed under a running bar after 300 ms. Skeleton rows are for `status="loading"` only.
+     */
+    refreshing?: boolean;
+    onRetry?: () => void;
+    /** The actors offered in the Who filter. Without them there is no Who filter. */
+    actors?: readonly FilterChoice[];
+    /**
+     * Names for actor ids in `filters.actor` that are not among `actors` (restored from a URL or a
+     * saved view): the Who chip shows the names, not the ids.
+     */
+    resolveActorLabels?: (ids: readonly string[]) => Promise<readonly FilterChoice[]>;
+    /** The filters in effect (controlled). With `onFiltersChange`, the filter bar shows. */
+    filters?: AuditLogFilters;
+    onFiltersChange?: (filters: AuditLogFilters) => void;
+    /** More, older entries exist: a Show older entries button calls `onLoadMore` (keyset paging). */
+    hasMore?: boolean;
+    onLoadMore?: () => void;
+    loadingMore?: boolean;
+    /** Loading older entries failed: the button stays to try again, with `labels.loadMoreFailed` beside it. */
+    loadMoreError?: boolean;
+    /** Locale of times and dates; a list falls back in order. */
+    locale?: string | readonly string[];
+    /**
+     * The exact time shown beside the relative one. Default: `Intl` medium date and short time in
+     * `locale`. Pass it where the browser lacks the locale's data (Chromium has none for `bs` and
+     * prints "2026 M10 22"), or for a fixed product format.
+     */
+    formatExact?: (date: Date) => string;
+    /**
+     * Time zone of the times shown, e.g. the practice's `Europe/Sarajevo`. Default: the viewer's.
+     * A zone the browser does not know falls back to the viewer's (with a warning in development).
+     */
+    timeZone?: string;
+    /** Formats `YYYY-MM-DD` in a filter chip. Default: as given. */
+    formatDate?: (date: string) => string;
+    /** The current time, for stable relative times in tests and server renders. */
+    now?: Date | number;
+    labels?: Partial<AuditLogLabels>;
+}
+/**
+ * Who opened or changed what, and when (HAR-987; MEDx S50 "Historija pristupa", POSx PRT-01 /
+ * INT-01): an ordered list of entries (actor, a labelled action, the target, a relative time
+ * with the exact one beside it, and an optional Details disclosure), filters by period, person
+ * and action (chips that open `FilterEditor`s), keyset "Show older entries", and the first-load,
+ * empty, filtered-empty, error and forbidden states. Presentational: the consumer fetches, keeps
+ * the audit semantics, and supplies entries free of health data.
+ */
+declare function AuditLog({ events, actions, status, refreshing, onRetry, actors, resolveActorLabels, filters, onFiltersChange, hasMore, onLoadMore, loadingMore, loadMoreError, locale, formatExact, timeZone: zoneProp, formatDate, now, labels: labelOverrides, className, ...props }: AuditLogProps): react.JSX.Element;
+
+interface TableWrapProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Polite live-region text for table state changes — "Sorted by …", "N results",
+     * "N selected". Pass `useTable().announcement` straight through (UIX-A11Y-2).
+     */
+    announcement?: string;
+    /**
+     * The rows are being fetched again (a filter, sort, page or saved-view change; HAR-2582). The
+     * current rows stay and dim under an indeterminate bar along the top, and the wrap is
+     * `aria-busy`; after 300 ms, held at least 500 ms. Keep the previous rows while fetching
+     * (TanStack Query `placeholderData: keepPreviousData`); skeleton rows are for a first load.
+     */
+    refreshing?: boolean;
+    children?: ReactNode;
+}
+declare const TableWrap: react.ForwardRefExoticComponent<TableWrapProps & react.RefAttributes<HTMLDivElement>>;
+type TableDensity = 'compact' | 'standard' | 'comfortable';
+type SortDirection = 'ascending' | 'descending' | 'none';
+interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
+    density?: TableDensity;
+    zebra?: boolean;
+    pinnedCol?: boolean;
+    /**
+     * Freeze the last column at the right edge while the wrap scrolls sideways, so a trailing
+     * row-actions column (peek, kebab) stays one click away. Pin the row's state with
+     * `Tr selected` / `Tr pinned`: the frozen cell repaints those, not a consumer's own row class.
+     */
+    pinnedActions?: boolean;
+    /** table-layout: fixed — required for reliable column widths + primary-column truncation */
+    fixed?: boolean;
+    rowPeek?: boolean;
+    v2?: boolean;
+}
+declare function Table({ density, zebra, pinnedCol, pinnedActions, fixed, rowPeek, v2, className, children, ...props }: TableProps): react.JSX.Element;
+interface ThProps extends ThHTMLAttributes<HTMLTableCellElement> {
+    sortable?: boolean;
+    sortDirection?: SortDirection;
+    /** 1-based ordinal shown when this column is a secondary key in a multi-sort */
+    sortOrder?: number;
+    onSort?: () => void;
+}
+declare function Th({ sortable, sortDirection, sortOrder, onSort, className, children, onClick, ...props }: ThProps): react.JSX.Element;
+interface TdProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    pinned?: boolean;
+}
+declare function Td({ pinned, className, children, ...props }: TdProps): react.JSX.Element;
+interface TrProps extends HTMLAttributes<HTMLTableRowElement> {
+    selected?: boolean;
+    pinned?: boolean;
+}
+declare function Tr({ selected, pinned, className, children, ...props }: TrProps): react.JSX.Element;
+interface BulkBarProps extends HTMLAttributes<HTMLDivElement> {
+    /** number of selected rows, rendered through `selectedLabel` */
+    count?: number;
+    children?: ReactNode;
+    /** TENSOR RX-125 (UIX-04): translatable; English default. */
+    label?: string;
+    /** TENSOR RX-125 (UIX-04): translatable; English default. */
+    selectedLabel?: (count: number) => ReactNode;
+}
+/** Contextual action bar shown above the table when ≥1 row is selected. */
+declare function BulkBar({ count, children, label, selectedLabel, className, ...props }: BulkBarProps): react.JSX.Element;
+interface RowActionsProps extends TdHTMLAttributes<HTMLTableCellElement> {
+    children?: ReactNode;
+}
+/** Trailing cell that holds the row's hover actions (kebab, quick actions). */
+declare function RowActions({ children, className, ...props }: RowActionsProps): react.JSX.Element;
+interface RowActionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode;
+}
+/** A single hover-revealed row action button (icon inside). */
+declare function RowAction({ children, className, type, ...props }: RowActionProps): react.JSX.Element;
+interface ExpandToggleProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** TENSOR RX-125 (UIX-04): translatable; English default. */
+    expandLabel?: string;
+    /** TENSOR RX-125 (UIX-04): translatable; English default. */
+    collapseLabel?: string;
+    expanded?: boolean;
+    /** id of the detail row this toggle controls → `aria-controls` (UIX-A11Y-2). */
+    controls?: string;
+}
+/** Chevron button that expands/collapses an inline detail row. */
+declare function ExpandToggle({ expanded, controls, expandLabel, collapseLabel, className, type, ...props }: ExpandToggleProps): react.JSX.Element;
+/** Emphasised primary cell text. */
+declare function CellStrong({ children, className, ...props }: HTMLAttributes<HTMLSpanElement>): react.JSX.Element;
+interface CellSubProps extends HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Tabular numerals (HAR-1815): for a read-back code, a reference or a time, so digits line up
+     * down the column and a 1 is as wide as an 8.
+     */
+    tabular?: boolean;
+}
+/** Secondary line under a primary cell value (muted, meta size). */
+declare function CellSub({ tabular, children, className, ...props }: CellSubProps): react.JSX.Element;
+interface MarkProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode;
+}
+/** A search-match highlight span. */
+declare function Mark({ children, className, ...props }: MarkProps): react.JSX.Element;
+interface HighlightedProps {
+    text: string;
+    query: string;
+}
+/** Render `text` with case-insensitive matches of `query` wrapped in <mark>. */
+declare function Highlighted({ text, query }: HighlightedProps): react.JSX.Element;
+
+interface ViewMenuColumn {
+    id: string;
+    label: ReactNode;
+    visible: boolean;
+    disabled?: boolean;
+    /** Always shown (e.g. the record id): the row has no checkbox and no Hide / Show, its name sits in the checkbox's slot. */
+    required?: boolean;
+    /** Plain-text name for the `{label}` templates in `columnLabels` when `label` is not a string. */
+    textLabel?: string;
+}
+/**
+ * Words for the column rows. `{label}` is replaced by the column name; `moved` also gets
+ * `{position}` and `{count}`. Every key has an English default.
+ */
+interface ViewMenuColumnLabels {
+    /** Name of a row's ⋯ menu button and of the menu. Default `Column actions: {label}`. */
+    rowActions: string;
+    /** Name of a row's drag grip. Default `Drag to reorder: {label}`. */
+    reorder: string;
+    moveUp: string;
+    moveDown: string;
+    hide: string;
+    show: string;
+    /** Tooltip on a required column's name. Default `Always shown`. */
+    required: string;
+    /** Polite announcement after a move. Default `{label} moved to position {position} of {count}`. */
+    moved: string;
+}
+interface ViewMenuProps {
+    /** The density section renders when `densityOptions` and `onDensityChange` are given. */
+    density?: string;
+    densityLabel?: ReactNode;
+    densityOptions?: readonly {
+        value: string;
+        label: ReactNode;
+    }[];
+    onDensityChange?: (value: string) => void;
+    /** Optional title over the zebra / freeze switches. */
+    displayLabel?: ReactNode;
+    zebra?: {
+        checked: boolean;
+        label: ReactNode;
+        onChange: (checked: boolean) => void;
+    };
+    freeze?: {
+        checked: boolean;
+        label: ReactNode;
+        onChange: (checked: boolean) => void;
+    };
+    columns?: readonly ViewMenuColumn[];
+    columnsLabel?: ReactNode;
+    onColumnVisibilityChange?: (id: string, visible: boolean) => void;
+    /**
+     * Turns on reordering: every column row gets a drag grip (pointer; ArrowUp / ArrowDown once
+     * focused) and a ⋯ menu with Move up · Move down · Hide / Show, which is the keyboard path.
+     * Receives every column id, first to last. The order is the application's to persist.
+     */
+    onReorder?: (orderedIds: string[]) => void;
+    columnLabels?: Partial<ViewMenuColumnLabels>;
+    /** Pinned under the columns, e.g. a Reset sort `.uix-menu__item` button. */
+    footer?: ReactNode;
+    className?: string;
+}
+/**
+ * Controlled table presentation panel with its own surface: density, zebra / freeze and a column
+ * list under sticky section titles. A column row is grip · checkbox · name · ⋯ (grip and ⋯ with
+ * `onReorder`). Usable inside a Popover or any overlay shell, including one that adds no chrome.
+ */
+declare function ViewMenu({ density, densityLabel, densityOptions, onDensityChange, displayLabel, zebra, freeze, columns, columnsLabel, onColumnVisibilityChange, onReorder, columnLabels, footer, className, }: ViewMenuProps): react.JSX.Element;
+interface FilterOption {
+    value: string;
+    label: string;
+}
+interface FilterPopoverProps {
+    label: ReactNode;
+    type?: 'text' | 'number' | 'date' | 'select' | 'enum' | 'boolean';
+    value: string;
+    onValueChange: (value: string) => void;
+    options?: readonly FilterOption[];
+    applyLabel: ReactNode;
+    clearLabel: ReactNode;
+    onApply: () => void;
+    onClear: () => void;
+    placeholder?: string;
+}
+/** Controlled filter editor content; applications own query serialization and the popover trigger. */
+declare function FilterPopover({ label, type, value, onValueChange, options, applyLabel, clearLabel, onApply, onClear, placeholder }: FilterPopoverProps): react.JSX.Element;
+interface SavedViewItem {
+    id: string;
+    label: ReactNode;
+    active?: boolean;
+    pinned?: boolean;
+}
+/** A titled group of saved views, e.g. the user's custom views above the built-in presets. */
+interface SavedViewSection {
+    id: string;
+    label: ReactNode;
+    items: readonly SavedViewItem[];
+}
+interface SavedViewMenuBaseProps {
+    onSelect: (id: string) => void;
+    emptyLabel?: ReactNode;
+    /** The row's overflow slot (e.g. a ⋯ menu trigger). It stays quiet until the row is hovered or focused, or its menu is open. */
+    actions?: (item: SavedViewItem) => ReactNode;
+    footer?: ReactNode;
+}
+type SavedViewMenuProps = SavedViewMenuBaseProps & ({
+    items: readonly SavedViewItem[];
+    sections?: never;
+} | {
+    sections: readonly SavedViewSection[];
+    items?: never;
+}) & ({
+    onPinChange: (id: string, pinned: boolean) => void;
+    pinLabel: string;
+    unpinLabel: string;
+} | {
+    onPinChange?: undefined;
+    pinLabel?: never;
+    unpinLabel?: never;
+}) & ({
+    /**
+     * Adds a drag grip to every row. Rows move only within their own section; the
+     * callback receives that section's full id order (and its id when `sections` is used).
+     * The grip also moves its row with ArrowUp / ArrowDown.
+     */
+    onReorder: (orderedIds: string[], sectionId: string | undefined) => void;
+    /** Accessible name of the grip; the row's name is attached as its description. */
+    reorderLabel: string;
+} | {
+    onReorder?: undefined;
+    reorderLabel?: never;
+});
+/**
+ * Generic saved-view selector: optional titled sections inside one `.uix-menu`, rows of
+ * grip · name · overflow. The selected row is tinted as a whole (no check glyph). Persistence,
+ * ownership, permissions and labels remain application concerns.
+ */
+declare function SavedViewMenu({ items, sections, onSelect, onPinChange, pinLabel, unpinLabel, onReorder, reorderLabel, emptyLabel, actions, footer }: SavedViewMenuProps): react.JSX.Element;
+
+/** Every word the workspace renders or announces. `{…}` are placeholders. */
+interface DataWorkspaceLabels {
+    search: string;
+    searchPlaceholder: string;
+    addFilter: string;
+    clearFilters: string;
+    /** The saved-view trigger's name before the current view: "View: {name}". */
+    savedView: string;
+    view: string;
+    saveView: string;
+    saveViewAs: string;
+    maximize: string;
+    restore: string;
+    selectAll: string;
+    /** `{label}`: the row's id. */
+    selectRow: string;
+    /** `{count}` selected, in the bulk bar. */
+    selected: string;
+    bulkActions: string;
+    /** The record-id cell's ↗ button. `{label}`. */
+    open: string;
+    rowActions: string;
+    /** Offset footer: `{from}`, `{to}`, `{total}`. */
+    range: string;
+    rowsPerPage: string;
+    loading: string;
+    empty: string;
+    emptyDetail: string;
+    filteredEmpty: string;
+    filteredEmptyDetail: string;
+    error: string;
+    retry: string;
+}
+declare const DEFAULT_DATA_WORKSPACE_LABELS: DataWorkspaceLabels;
+interface DataWorkspaceColumn<T> {
+    id: string;
+    header: ReactNode;
+    cell: (row: T) => ReactNode;
+    sortable?: boolean;
+    /** `end` for numbers and amounts. */
+    align?: 'start' | 'end';
+    /** A CSS width for the column, e.g. `12rem`. */
+    width?: string;
+}
+interface DataWorkspaceSort {
+    columnId: string;
+    direction: 'ascending' | 'descending';
+}
+/** The record-id column: the first column, the row's way into its record. */
+interface DataWorkspaceIdColumn<T> {
+    header: ReactNode;
+    /** The id as shown, e.g. "INC-20418". Also names the row's checkbox and ↗ button. */
+    text: (row: T) => string;
+    /** The id button opens a peek of the record. */
+    onPeek?: (row: T) => void;
+    /** The ↗ link goes to the full record. */
+    href?: (row: T) => string;
+    renderLink?: UixRenderLink;
+}
+type DataWorkspacePagination = {
+    mode: 'offset';
+    page: number;
+    pageSize: number;
+    total: number;
+    onPageChange: (page: number) => void;
+    pageSizes?: readonly number[];
+    onPageSizeChange?: (size: number) => void;
+} | {
+    mode: 'cursor';
+    hasPrevious: boolean;
+    hasNext: boolean;
+    onFirst?: () => void;
+    onPrevious: () => void;
+    onNext: () => void;
+    summary?: ReactNode;
+    pageSize?: number;
+    pageSizes?: readonly number[];
+    onPageSizeChange?: (size: number) => void;
+};
+interface DataWorkspaceProps<T> extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    /** Names the workspace region and the table. */
+    label: string;
+    rows: readonly T[];
+    getRowId: (row: T) => string;
+    columns: readonly DataWorkspaceColumn<T>[];
+    idColumn?: DataWorkspaceIdColumn<T>;
+    sort?: DataWorkspaceSort | null;
+    onSortChange?: (sort: DataWorkspaceSort | null) => void;
+    /** The selected row ids. Kept by id, so a refresh or a new page keeps them. */
+    selection?: ReadonlySet<string>;
+    onSelectionChange?: (selection: Set<string>) => void;
+    /** The bulk bar's actions for the selection (a `Menu` for the overflow). */
+    bulkActions?: (selectedIds: string[]) => ReactNode;
+    /**
+     * A row's actions (a `Menu`, quick buttons), in a column frozen at the right edge and sized to
+     * them. Return `null` for a row without actions; with none on the page there is no column.
+     */
+    rowActions?: (row: T) => ReactNode;
+    /** More props for a row, e.g. a data attribute that marks it changed (see ChangeHighlight, PR #164). */
+    getRowProps?: (row: T) => HTMLAttributes<HTMLTableRowElement> & Record<`data-${string}`, string | undefined>;
+    density?: TableDensity;
+    /**
+     * Toolbar: the search field. Ctrl/⌘ + / focuses it from inside the workspace, or from the page
+     * when nothing has focus and this is the page's first workspace.
+     */
+    search?: {
+        value: string;
+        onChange: (value: string) => void;
+        label?: string;
+        placeholder?: string;
+    };
+    /**
+     * Toolbar: filter chips and "+ Filter" over `FilterEditor`. A chip whose value holds ids
+     * restored from a URL or saved view asks `field.resolveLabels` for their names.
+     */
+    filters?: {
+        fields: readonly FilterField[];
+        values: Readonly<Record<string, FilterValue | undefined>>;
+        onChange: (fieldId: string, value: FilterValue | undefined) => void;
+        /** Rows matching each filter, shown on its chip. */
+        counts?: Readonly<Record<string, number>>;
+        summary?: SummarizeFilterOptions;
+    };
+    /** Toolbar: the saved-view trigger, named by the current view, opening a `SavedViewMenu`. */
+    savedViews?: {
+        current: ReactNode;
+        menu: SavedViewMenuProps;
+    };
+    /** Toolbar: the View button, opening a `ViewMenu` (columns, density). */
+    viewMenu?: ViewMenuProps;
+    /** The view differs from its saved version: Save changes and Save as show. */
+    viewChanged?: boolean;
+    onSaveView?: () => void;
+    onSaveViewAs?: () => void;
+    /** Toolbar: a maximize toggle; Escape restores, unless an open popover or menu takes it first. */
+    maximized?: boolean;
+    onMaximizedChange?: (maximized: boolean) => void;
+    /** Toolbar: the product's own actions at the end ("New incident"). */
+    toolbarEnd?: ReactNode;
+    pagination?: DataWorkspacePagination;
+    /** `loading`: the first load (skeleton rows). `error`: with `onRetry`. */
+    status?: 'ready' | 'loading' | 'error';
+    /** A refetch (filter, sort, page, saved view): the rows stay under `TableWrap refreshing`. */
+    refreshing?: boolean;
+    onRetry?: () => void;
+    labels?: Partial<DataWorkspaceLabels>;
+}
+/**
+ * The generic presentation half of a product's data table (HAR-1388; TENSOR `data-table.tsx`,
+ * MOTUS `UixDataWorkspace.tsx`; UIx ADR-0005). Composes the kit's pieces in one order: saved
+ * view · Save changes / Save as (when the view changed) · filter chips and "+ Filter" ·
+ * search (Ctrl/⌘ + /) · View · maximize · the product's actions; a `Table` with a record-id cell (id → peek, ↗ → record),
+ * selection with Shift-click ranges, a frozen row-actions column and a `BulkBar`; an "x–y of N"
+ * footer with rows per page and `Pagination` (offset or cursor); first-load, empty,
+ * filtered-empty and error states, and a refetch that keeps the rows. Prop-driven: the product
+ * keeps its surface registry, URL state, data fetching and permissions.
+ */
+declare function DataWorkspace<T>({ label, rows, getRowId, columns, idColumn, sort, onSortChange, selection, onSelectionChange, bulkActions, rowActions, getRowProps, density, search, filters, savedViews, viewMenu, viewChanged, onSaveView, onSaveViewAs, maximized, onMaximizedChange, toolbarEnd, pagination, status, refreshing, onRetry, labels: labelOverrides, className, ...props }: DataWorkspaceProps<T>): react.JSX.Element;
+
+/**
+ * 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
+ * provider; an explicit prop on one instance still wins.
+ *
+ * Client components read the provider. Server-renderable ones (`Pagination`, `BulkBar`)
+ * cannot read context: pass `labels` from `useUixLabels()` in a client parent, or translate
+ * on the server.
+ */
+interface UixLabels {
+    /** The words a `Button` with `result` shows for a moment after its action (HAR-2581). */
+    buttonResult?: Partial<ButtonResultLabels>;
+    modal?: {
+        close?: string;
+    };
+    drawer?: {
+        close?: string;
+    };
+    /** The "Discard changes?" step of a `dirty` Drawer or Modal (HAR-2029). */
+    discardPrompt?: Partial<DiscardPromptLabels>;
+    peek?: {
+        previous?: string;
+        next?: string;
+        close?: string;
+    };
+    /** `Lightbox` (HAR-1826): previous / next / close, the counter, the zoom toggle. */
+    lightbox?: Partial<LightboxLabels>;
+    toast?: {
+        dismiss?: string;
     };
     toaster?: {
         region?: string;
     };
+    /**
+     * `openNav`: the phone-tier button that opens the navigation drawer; `navigation`: that
+     * drawer's title (HAR-1371).
+     */
     appShell?: {
         skipToContent?: string;
         exitFocus?: string;
+        openNav?: string;
+        navigation?: string;
     };
+    /** `ThemeSwitcher` and `DisplayPreferences` (HAR-1372): the setting names and their choices. */
+    displayPreferences?: Partial<DisplayPreferencesLabels>;
+    /** `AccountMenu` (HAR-1371): the menu's name. */
+    accountMenu?: Partial<AccountMenuLabels>;
     sidebar?: {
         expand?: string;
         collapse?: string;
@@ -2916,32 +5125,65 @@ interface UixLabels {
     };
     /** `SearchBar` (HAR-2030): the clear button's name and the submit button's text. */
     searchBar?: Partial<SearchBarLabels>;
-    /** `resultsOne` / `resultsMany`: the polite result count; `{count}`. */
+    /**
+     * `resultsOne` / `resultsMany`: the polite result count; `{count}`. Items mode (HAR-1378):
+     * `empty` when nothing matches, `recent` the heading of the recent items.
+     */
     commandPalette?: {
         input?: string;
         resultsOne?: string;
         resultsMany?: string;
+        empty?: string;
+        recent?: string;
     };
+    /** `QrCode` (HAR-1251): the text shown when the value is too long for a QR code. */
+    qrCode?: Partial<QrCodeLabels>;
+    /** `CodeDisplay` (HAR-1253): the countdown, the expiry announcements, the copy button's words. */
+    codeDisplay?: Partial<CodeDisplayLabels>;
+    /** `ContactCard` (HAR-1379): the Email / Call actions and the erased and unavailable states. */
+    contactCard?: Partial<ContactCardLabels>;
+    /** `PrintSignature` (HAR-986): the captions of the signature line and the stamp box. */
+    printLayout?: Partial<PrintLayoutLabels>;
+    /** `QrScanner` (HAR-1254): the start / stop buttons, every state's title and text, the read announcement. */
+    qrScanner?: Partial<QrScannerLabels>;
     entityPicker?: Partial<EntityPickerLabels>;
     tree?: Partial<TreeLabels>;
     /** `OrgChart` (HAR-1807): loading and error rows, the report count, the zoom toolbar. */
     orgChart?: Partial<OrgChartLabels>;
     inlineEdit?: Partial<InlineEditLabels>;
+    /** `SortableList` (HAR-1375): the grip, Move up / Move down, the move announcement. */
+    sortableList?: Partial<SortableListLabels>;
+    /** `typeToConfirmMismatch` (HAR-1831): `{value}` is the text to type. */
     confirmDialog?: {
         typeToConfirm?: string;
         compensation?: string;
+        typeToConfirmMismatch?: string;
     };
     schedulingCalendar?: Partial<SchedulingCalendarLabels>;
     dateRangePicker?: Partial<DateRangePickerLabels>;
     datePicker?: Partial<DatePickerLabels>;
     dateTimePicker?: Partial<DateTimePickerLabels>;
+    /** `TimePicker` (HAR-1835), also the time part of `DateTimePicker`. */
+    timePicker?: Partial<TimePickerLabels>;
     schedulingTimeline?: Partial<SchedulingTimelineLabels>;
     textDiff?: Partial<TextDiffLabels>;
+    /** `DiffViewer` (HAR-1369): the version names, the resolution buttons, the summary. */
+    diffViewer?: Partial<DiffViewerLabels>;
+    /** `MatchReview` (HAR-1369): the decision table, bulk actions and the adopt mode. */
+    matchReview?: Partial<MatchReviewLabels>;
+    /** `AuditLog` (HAR-987): the filters, Details, Show older entries, and every state. */
+    auditLog?: Partial<AuditLogLabels>;
+    /** `DataWorkspace` (HAR-1388): the toolbar, selection, footer and states. */
+    dataWorkspace?: Partial<DataWorkspaceLabels>;
     filterEditor?: Partial<FilterEditorLabels>;
     select?: Partial<SelectLabels>;
     ruleBuilder?: Partial<RuleBuilderLabels>;
     fileUpload?: Partial<FileUploadLabels>;
     attachment?: Partial<AttachmentLabels>;
+    /** `TagInput` (HAR-1377): the chips' × names, the announcements and the refusals. */
+    tagInput?: Partial<TagInputLabels>;
+    /** `PasswordInput` (HAR-1376): the reveal toggle's name. */
+    passwordInput?: Partial<PasswordInputLabels>;
     /** `remove`: the name of a removable chip's × button; `{label}` is the chip text. */
     chip?: {
         remove?: string;
@@ -2950,6 +5192,8 @@ interface UixLabels {
     alert?: {
         dismiss?: string;
     };
+    /** Not words: the date format of every date field (HAR-2432). See {@link UixDateFormat}. */
+    dateFormat?: UixDateFormat;
     /** 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`. */
@@ -2957,44 +5201,57 @@ interface UixLabels {
         region?: string;
     };
 }
+/**
+ * One date format for every date field below the provider (HAR-2432): `DatePicker`,
+ * `DateTimePicker`, `DateRangePicker` and `TimePicker` (its `locale`). Each field's own prop wins.
+ */
+interface UixDateFormat {
+    /** The locale of the field's text, month and weekday names, and the clock. */
+    locale?: string;
+    /** How a field writes a `YYYY-MM-DD` date, e.g. `(d) => d.split('-').reverse().join('.')`. */
+    formatDate?: (date: string) => string;
+    /** Read typed text into `YYYY-MM-DD`, or `null` when it is not a date. Pass it with `formatDate`. */
+    parseDate?: (text: string) => string | null;
+    /** The date field's placeholder, e.g. `TT.MM.JJJJ`. */
+    placeholder?: string;
+}
 interface UixLabelsProviderProps {
     labels: UixLabels;
     children?: ReactNode;
 }
-/** Translates kit chrome once for a subtree. Nested providers merge per component. */
-declare function UixLabelsProvider({ labels, children }: UixLabelsProviderProps): react.JSX.Element;
-/** The chrome strings in effect here (empty outside a provider). */
-declare function useUixLabels(): UixLabels;
-
-interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
-    size?: 'sm' | 'md';
-    invalid?: boolean;
-    valid?: boolean;
-    /**
-     * "Check this": a value the reader should confirm, not an error, e.g. one an assistant filled
-     * in (HAR-1814). Draws the warning border; `invalid` wins when both are set.
-     */
-    warning?: boolean;
-}
-declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
-interface InputGroupProps {
-    children: ReactNode;
-    leadingIcon?: ReactNode;
-    trailingIcon?: ReactNode;
-    className?: string;
-    /** Injected by `<Field>` when it wraps the group; forwarded onto the child control. */
-    id?: string;
-    'aria-describedby'?: string;
+/** Translates kit chrome once for a subtree. Nested providers merge per component. */
+declare function UixLabelsProvider({ labels, children }: UixLabelsProviderProps): react.JSX.Element;
+/** The chrome strings in effect here (empty outside a provider). */
+declare function useUixLabels(): UixLabels;
+
+interface OtpInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'defaultValue' | 'onChange' | 'type' | 'size' | 'maxLength' | 'pattern' | 'inputMode'> {
+    /** How many characters the code has. Default 6. */
+    length?: number;
+    /** Controlled value: the characters typed so far. */
+    value?: string;
+    defaultValue?: string;
+    /** Every change, with the cleaned code (only allowed characters, at most `length`). */
+    onValueChange?: (value: string) => void;
+    /** Called once each time the code reaches `length` characters. */
+    onComplete?: (code: string) => void;
+    /** `numeric` (default): digits, with the phone's number pad. `alphanumeric`: letters and digits, upper-cased. */
+    mode?: 'numeric' | 'alphanumeric';
+    /** Draw a gap after every n cells (3 → "123 456"). Visual only: the value has no separator. */
+    groupSize?: number;
+    invalid?: boolean;
     'aria-invalid'?: AriaAttributes['aria-invalid'];
-    'aria-required'?: AriaAttributes['aria-required'];
+    className?: string;
+    style?: CSSProperties;
 }
 /**
- * Icon-adorned wrapper for a child `<Input>`. The control is passed as `children`, so
- * `<Field>`'s injected `id`/`aria-*` land on this wrapper — they're forwarded onto the
- * single child element (the child's own props win) so label/message association survives
- * the extra div (UIX-A11Y-3).
+ * A one-time code (HAR-1376): ONE native input, so screen readers, the phone's code autofill
+ * (`autoComplete="one-time-code"`) and password managers see a single field, drawn as `length`
+ * cells. Pasting "123 456" or "123-456" keeps the characters; typing past the end is ignored;
+ * Backspace deletes the last one. `onComplete(code)` runs when the last character arrives. Put it in
+ * a `Field` for its label, hint and error (the cells turn red with `aria-invalid`). `name` submits
+ * the code. `ref` is the input.
  */
-declare function InputGroup({ children, leadingIcon, trailingIcon, className, id, 'aria-describedby': describedBy, 'aria-invalid': invalid, 'aria-required': required, }: InputGroupProps): react.JSX.Element;
+declare const OtpInput: react.ForwardRefExoticComponent<OtpInputProps & react.RefAttributes<HTMLInputElement>>;
 
 interface ComboboxOption {
     value: string;
@@ -3002,21 +5259,50 @@ interface ComboboxOption {
     keywords?: readonly string[];
     disabled?: boolean;
 }
+/** A titled group of options (HAR-1588). */
+interface ComboboxGroup {
+    label: string;
+    options: readonly ComboboxOption[];
+    /** Disables every option in the group. */
+    disabled?: boolean;
+}
 declare function filterComboboxOptions(options: readonly ComboboxOption[], query: string): ComboboxOption[];
+/** Options and groups that match `query` (label, value or keywords); a group stays when any of its options does. */
+declare function filterComboboxItems(items: readonly (ComboboxOption | ComboboxGroup)[], query: string): (ComboboxOption | ComboboxGroup)[];
 
 interface ComboboxProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
-    options: readonly ComboboxOption[];
+    /** The options, and groups of options (`{ label, options }`, HAR-1588). */
+    options: readonly (ComboboxOption | ComboboxGroup)[];
     value?: string;
     defaultValue?: string;
     onValueChange?: (value: string, option: ComboboxOption) => void;
+    /** The field's name. Not used as its name when `aria-labelledby` points at a visible label. */
     label: string;
     placeholder?: string;
+    /** Shown in the open list when nothing matches (outside the listbox, so it is never an option). */
     emptyLabel: string;
     name?: string;
     disabled?: boolean;
+    /** Ids of the visible label(s) that name the field; replaces `label` as its name. */
+    'aria-labelledby'?: string;
+    /** Ids of hint or error text; lands on the input. */
+    'aria-describedby'?: string;
+    'aria-invalid'?: AriaAttributes['aria-invalid'];
+    /** Id of the input itself (for a `<label for>`); `id` stays on the wrapper. */
+    inputId?: string;
+    /** Preferred side of the list. Default `'bottom-start'`; it flips when there is no room. */
+    placement?: Placement;
 }
-/** Searchable single-select combobox with keyboard navigation and no framework dependencies. */
-declare function Combobox({ options, value, defaultValue, onValueChange, label, placeholder, emptyLabel, name, disabled, className, ...props }: ComboboxProps): react.JSX.Element;
+/**
+ * An editable combobox (HAR-1588): type to filter, choose with the keyboard or the pointer. It
+ * follows the WAI-ARIA APG combobox with a listbox popup, at parity with `Select`: the list is a
+ * top-layer popover placed with `useAnchoredPosition`, so a Drawer, a Popover or an
+ * `overflow: hidden` cell never clips it; ↑ ↓ PageUp PageDown move (Home and End too while an
+ * option is active), disabled options are skipped and the list does not wrap; Enter chooses;
+ * Escape closes the list and puts the chosen option's text back, as leaving the field does.
+ * Groups render as `role="group"`; the no-match row sits outside the listbox.
+ */
+declare function Combobox({ options, value, defaultValue, onValueChange, label, placeholder, emptyLabel, name, disabled, className, 'aria-labelledby': ariaLabelledBy, 'aria-describedby': ariaDescribedBy, 'aria-invalid': ariaInvalid, inputId, placement, ...props }: ComboboxProps): react.JSX.Element;
 
 /** One run of a result's text, emphasised or not. */
 interface SearchSegment {
@@ -3039,14 +5325,48 @@ declare function searchSegments(text: string, query: string): SearchSegment[];
 
 interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     invalid?: boolean;
+    /**
+     * `lg`: the public-page size beside `Input size="lg"` and `Button size="lg"` (HAR-1812): larger
+     * text and padding, never shorter than 44 px. It still grows with `rows` and the resize handle.
+     */
+    size?: 'md' | 'lg';
 }
 declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
 
+/** Move `id` to `index` within `ids`. Returns `ids` itself when nothing moves. */
+declare function placeId(ids: readonly string[], id: string, index: number): readonly string[];
+
 interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
     label?: ReactNode;
     indeterminate?: boolean;
 }
 declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+interface CheckboxGroupProps {
+    children: ReactNode;
+    /** The group's name, rendered as the `<legend>`: announced with each checkbox (HAR-1799). */
+    label: ReactNode;
+    /** Help under the boxes, tied to the group with `aria-describedby`. */
+    hint?: ReactNode;
+    /** Shown instead of the hint and announced (`role="alert"`). */
+    error?: ReactNode;
+    /** Draws the required marker after the legend. Which boxes must be ticked is your rule to check. */
+    required?: boolean;
+    /** Disables every checkbox in the group (a disabled `<fieldset>`). */
+    disabled?: boolean;
+    /**
+     * The most columns the boxes form. Default 1. A column is never narrower than 10rem: on a phone,
+     * or in a narrow card, the boxes fall back to fewer columns.
+     */
+    columns?: number;
+    id?: string;
+    className?: string;
+}
+/**
+ * Checkboxes under one name (HAR-1799; MOTUS UXR-05): a `<fieldset>` whose `<legend>` names the
+ * group, so a screen reader says "Tags, group" before each box, with the field's hint and error
+ * slot below. The checkbox counterpart of `<RadioGroup label>`. Put `Checkbox`es inside.
+ */
+declare function CheckboxGroup({ children, label, hint, error, required, disabled, columns, id, className }: CheckboxGroupProps): react.JSX.Element;
 
 interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
     label?: ReactNode;
@@ -3141,8 +5461,17 @@ interface ModalProps extends Omit<HTMLAttributes<HTMLDialogElement>, 'title'> {
      */
     instant?: boolean;
 }
-declare function Modal({ open, onClose, dirty, pending, discardLabels, title, children, footer, className, closeLabel: closeLabelProp, role, instant, onKeyDown, ...rest }: ModalProps): react.JSX.Element;
+/** A modal `<dialog>`; the ref reaches it (HAR-1831). */
+declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDialogElement>>;
 
+/**
+ * Attributes for a dialog's confirm button (HAR-1831): `data-*` (TENSOR puts `data-action-id`
+ * there), `id`, `className`, an `aria-describedby`. Its `onClick` runs first; `preventDefault()`
+ * there stops the confirm. `disabled` adds to the dialog's own reasons to disable it.
+ */
+type ConfirmButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'type'> & {
+    [dataAttribute: `data-${string}`]: string | number | boolean | undefined;
+};
 interface ConfirmDialogProps {
     open: boolean;
     title: ReactNode;
@@ -3153,6 +5482,11 @@ interface ConfirmDialogProps {
     closeLabel?: string;
     onConfirm: () => void | Promise<void>;
     onCancel: () => void;
+    /**
+     * The confirmed action is running: Confirm shows its loading state, Cancel is disabled, and
+     * Escape, the × and a press on Cancel do nothing until it settles (HAR-1831), so the person
+     * cannot walk away from an action that is still being carried out.
+     */
     pending?: boolean;
     destructive?: boolean;
     /**
@@ -3175,21 +5509,47 @@ interface ConfirmDialogProps {
      * this text, e.g. the record's name.
      */
     typeToConfirm?: string;
-    /** Label of the type-to-confirm field. `{value}` is replaced by `typeToConfirm`. */
-    typeToConfirmLabel?: string;
+    /**
+     * Label of the type-to-confirm field. In a string, `{value}` is replaced by `typeToConfirm`;
+     * pass a node for markup, e.g. the value in `<code>` (HAR-1831).
+     */
+    typeToConfirmLabel?: ReactNode;
+    /** Placeholder of the type-to-confirm field, e.g. the value itself (HAR-1831). */
+    typeToConfirmPlaceholder?: string;
+    /**
+     * Shown under the field (and its description) once the typed text stops matching; `{value}` is
+     * replaced by `typeToConfirm` (HAR-1831). Default: `UixLabelsProvider` `confirmDialog`, then
+     * "That does not match {value}."
+     */
+    typeToConfirmMismatch?: string;
     /** How the action is undone or compensated, shown as its own labelled block (TENSOR C2). */
     compensation?: ReactNode;
     /** Heading of the compensation block. Default "How to undo this". */
     compensationLabel?: string;
+    /** Attributes for the confirm button, e.g. `{ 'data-action-id': 'ci.delete' }` (HAR-1831). */
+    confirmProps?: ConfirmButtonProps;
 }
-/** Generic confirmation shell. Audit, authorization and compensation policy remain application-owned. */
-declare function ConfirmDialog({ open, title, description, confirmLabel, cancelLabel, closeLabel, onConfirm, onCancel, pending, destructive, children, error, initialFocus, tertiaryLabel, onTertiary, typeToConfirm, typeToConfirmLabel: typeToConfirmLabelProp, compensation, compensationLabel: compensationLabelProp, }: ConfirmDialogProps): react.JSX.Element;
+/**
+ * Generic confirmation shell. Audit, authorization and compensation policy remain application-owned.
+ * The ref reaches the `<dialog>` (HAR-1831).
+ */
+declare const ConfirmDialog: react.ForwardRefExoticComponent<ConfirmDialogProps & react.RefAttributes<HTMLDialogElement>>;
 interface PopconfirmProps {
     open: boolean;
     /** The control that asked for confirmation; the step is placed against it and focus returns to it. */
     anchor: RefObject<HTMLElement | null> | HTMLElement | null;
-    title: ReactNode;
+    /**
+     * The question. Optional (HAR-1831): without it the step is named by its confirm button
+     * ("Delete"), which then has to say what it does.
+     */
+    title?: ReactNode;
     description?: ReactNode;
+    /**
+     * Content between the text and the buttons, e.g. a required reason field (HAR-1831). When it
+     * holds a field, that field has focus when the step opens, and the step takes its full width.
+     * Pair a required field with `confirmDisabled` until it is filled.
+     */
+    children?: ReactNode;
     confirmLabel: ReactNode;
     cancelLabel: ReactNode;
     onConfirm: () => void | Promise<void>;
@@ -3197,17 +5557,39 @@ interface PopconfirmProps {
     onCancel: () => void;
     pending?: boolean;
     destructive?: boolean;
+    /** Confirm cannot be pressed yet, e.g. while a required reason is empty (HAR-1831). */
+    confirmDisabled?: boolean;
+    /** Attributes for the confirm button, as on `ConfirmDialog` (HAR-1831). */
+    confirmProps?: ConfirmButtonProps;
     /** How the action is undone, under its own heading (TENSOR C2 "single_click" tier). */
     compensation?: ReactNode;
     compensationLabel?: string;
     placement?: Placement;
+    /** Default: `'alertdialog'` when `destructive`, else `'dialog'` (HAR-1831). */
+    role?: 'dialog' | 'alertdialog';
+    /**
+     * What names the step: its `title` (default when there is one) or its confirm button
+     * (default without a title) (HAR-1831).
+     */
+    labelledBy?: 'title' | 'confirm';
+    /**
+     * Called with the Escape keydown before the step cancels; `event.preventDefault()` keeps it open
+     * (HAR-1831). The step only takes an Escape that is its own: not while a popup inside it is open
+     * (a Select's list), not one meant for a dialog opened above it, and only the newest open step.
+     */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /**
+     * Cancel when the anchor has scrolled out of view (outside the viewport or a clipping ancestor),
+     * rather than leave the step floating over unrelated content (HAR-1831). Default `false`.
+     */
+    closeWhenAnchorHidden?: boolean;
 }
 /**
  * An anchored, single-step confirmation for low-risk actions (HAR-1356; TENSOR C2): a small
- * `role="dialog"` on the kit `Popover`, focus on Cancel, Escape or a press outside cancels,
- * and focus returns to the anchor. Use `ConfirmDialog` when the action is hard to undo.
+ * dialog on the kit `Popover`, focus on Cancel (or on a field in its content), Escape or a press
+ * outside cancels, and focus returns to the anchor. Use `ConfirmDialog` when the action is hard to undo.
  */
-declare function Popconfirm({ open, anchor, title, description, confirmLabel, cancelLabel, onConfirm, onCancel, pending, destructive, compensation, compensationLabel: compensationLabelProp, placement, }: PopconfirmProps): react.JSX.Element;
+declare function Popconfirm({ open, anchor, title, description, children, confirmLabel, cancelLabel, onConfirm, onCancel, pending, destructive, confirmDisabled, confirmProps, compensation, compensationLabel: compensationLabelProp, placement, role, labelledBy, onEscapeKeyDown, closeWhenAnchorHidden, }: PopconfirmProps): react.JSX.Element;
 interface PromptDialogProps {
     open: boolean;
     title: ReactNode;
@@ -3301,47 +5683,6 @@ 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. */
@@ -3374,6 +5715,23 @@ 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;
+interface InsetProps extends HTMLAttributes<HTMLDivElement> {
+    /** `md` (default) pads with `--uix-space-4`; `sm` with `--uix-space-3`, for a dense card. */
+    padding?: 'sm' | 'md';
+    /**
+     * `sunken` (default) is `--uix-bg-subtle` on the card's surface; `surface` is for a well on a
+     * panel that is already subtle.
+     */
+    tone?: 'sunken' | 'surface';
+    children?: ReactNode;
+}
+/**
+ * A bordered, sunken well inside a card body (HAR-1818), over `.uix-inset`: for a preview or a
+ * specimen (a rendered header, an image crop, a code sample). Use it instead of a `Card` in a
+ * `Card`, which brings a second shadow, card padding and card semantics. It lays out nothing:
+ * the content is yours. Give it `role="group"` and an `aria-label` when the preview needs a name.
+ */
+declare function Inset({ padding, tone, children, className, ...props }: InsetProps): react.JSX.Element;
 
 /** Columns at one width. */
 type DashboardGridColumnCount = 1 | 2 | 3 | 4;
@@ -3617,9 +5975,15 @@ interface BreadcrumbsProps extends Omit<HTMLAttributes<HTMLElement>, 'children'>
     items: readonly BreadcrumbItem[];
     label: string;
     separator?: ReactNode;
+    /**
+     * Renders each item's link with your router (HAR-1385): `renderLink={(p) => <NextLink {...p} />}`
+     * keeps client navigation and prefetch, and a locale-aware link adds the locale prefix. The
+     * same `UixRenderLink` adapter as `ButtonLink`, `Stat`, `Pagination` and `Steps`. Default: `<a>`.
+     */
+    renderLink?: UixRenderLink;
 }
-/** Framework-neutral breadcrumb navigation. Route adapters can replace anchors at the application seam. */
-declare function Breadcrumbs({ items, label, separator, className, ...props }: BreadcrumbsProps): react.JSX.Element;
+/** Framework-neutral breadcrumb navigation; `renderLink` renders the links with the app's router. */
+declare function Breadcrumbs({ items, label, separator, renderLink, className, ...props }: BreadcrumbsProps): react.JSX.Element;
 
 interface PageHeaderProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
     eyebrow?: ReactNode;
@@ -3637,12 +6001,18 @@ interface PageHeaderProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
     helpLabel?: string;
     /** Right-aligned action area (buttons, menus). */
     actions?: ReactNode;
+    /**
+     * `display` is the staff type preset (HAR-1815; TENSOR, MOTUS ADR-0047): a 40 px heading-font
+     * title, a bold hushed eyebrow, a body-size hushed subtitle up to 42rem, and the actions
+     * aligned to the bottom of the titles. `default` is the 24 px header.
+     */
+    size?: 'default' | 'display';
 }
 /**
  * Page header — eyebrow / title (+ optional `help` ?) / subtitle + actions row, over `.uix-page-header`.
  * The hairline + breathing room below come from the component CSS.
  */
-declare function PageHeader({ eyebrow, title, subtitle, help, helpLabel, actions, as: TitleTag, className, ...props }: PageHeaderProps): react.JSX.Element;
+declare function PageHeader({ eyebrow, title, subtitle, help, helpLabel, actions, as: TitleTag, size, className, ...props }: PageHeaderProps): react.JSX.Element;
 
 interface DetailLayoutProps extends HTMLAttributes<HTMLDivElement> {
     /** The narrow trailing column (record meta, side panels). */
@@ -3700,9 +6070,15 @@ interface DetailPageProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
      * modified click, no JS).
      */
     onTabSelect?: (id: string) => void;
+    /**
+     * `staff` is the staff type preset (HAR-1815): the title at h2 with its 1.15 leading, the back
+     * link an inline hushed link without an underline, and each metric's label an eyebrow over an
+     * h3-size, regular-weight, tabular value. `default` is the plain record page.
+     */
+    variant?: 'default' | 'staff';
 }
 /** Framework-neutral record-detail scaffold; routing and data policy stay with the application. */
-declare function DetailPage({ back, eyebrow, title, subtitle, actions, tabs, metrics, side, children, tabsLabel, renderLink, onTabSelect, className, ...props }: DetailPageProps): react.JSX.Element;
+declare function DetailPage({ back, eyebrow, title, subtitle, actions, tabs, metrics, side, children, tabsLabel, renderLink, onTabSelect, variant, className, ...props }: DetailPageProps): react.JSX.Element;
 
 interface RelatedLinkItem {
     id: string;
@@ -3885,7 +6261,8 @@ interface TabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'r
     children?: ReactNode;
     className?: string;
     /**
-     * What happens when the tabs don't fit. `'wrap'` (default) keeps today's layout.
+     * What happens when the tabs don't fit. `'wrap'` (default): the tab row wraps onto more rows,
+     * and no tab is wider than its row, so one long label wraps inside its tab (HAR-1754).
      * `'scroll'` keeps one row that scrolls sideways, with pointer-only edge buttons
      * shown on the side that has hidden tabs. The selected tab is always scrolled into view.
      */
@@ -3927,8 +6304,47 @@ declare function TabPanel({ value, children, keepMounted, ...props }: TabPanelPr
 
 type ShellNav = 'full' | 'rail' | 'hidden';
 interface AppShellProps extends HTMLAttributes<HTMLDivElement> {
-    /** Sidebar width tier: 'full' (default) → 'rail' (icon only) → 'hidden' (0). */
+    /**
+     * `frame` (default) is the bordered, rounded box the docs show a shell in. `viewport` is an
+     * application's shell (HAR-1815): no frame, the full dynamic viewport height (`100dvh`), no fixed
+     * top-bar row (the sidebar and main both run the full height; a `topbar`, if given, sits at the
+     * top of the main column), main padding that widens on wide screens, and the phone nav tier by
+     * default (`phoneNav`), so below 40rem it is one column with the sidebar in a drawer.
+     */
+    layout?: 'frame' | 'viewport';
+    /**
+     * Sidebar width tier: 'full' (default) → 'rail' (icon only) → 'hidden' (0). Controlled when
+     * set; leave it out to let the shell keep the tier (`defaultNav`, `navHotkey`,
+     * `navTierStorageKey`).
+     */
     nav?: ShellNav;
+    /** The starting tier when `nav` is not controlled. Default `full`. */
+    defaultNav?: ShellNav;
+    /**
+     * Called with the tier the hotkey asks for, and once on mount with a remembered tier that
+     * differs from `defaultNav` (HAR-1371), so a `Sidebar nav` you render can follow. With `nav`
+     * controlled, set it from here.
+     */
+    onNavChange?: (nav: ShellNav) => void;
+    /**
+     * A key that switches the sidebar between `full` and `rail` (HAR-1371; MOTUS StaffShell), e.g.
+     * `"["`. It is ignored while typing in a field or with Ctrl/⌘/Alt held, and from `hidden` it
+     * goes to `full`. The switch is instant.
+     */
+    navHotkey?: string;
+    /**
+     * Remember the tier in `localStorage` under this key (HAR-1371), so a reload keeps the rail.
+     * Applied before the first paint on the client; the server renders `defaultNav`.
+     */
+    navTierStorageKey?: string;
+    /**
+     * The phone nav tier (HAR-1371): at 40rem and under, the sidebar column is hidden and a menu
+     * button (at the start of the topbar, or at the top of main) opens the sidebar in a start-side
+     * `Drawer`, shown full whatever the tier. Following a link in it closes the drawer. Default
+     * `drawer` with `layout="viewport"`, `none` with the frame; `none` keeps the sidebar column at
+     * every width.
+     */
+    phoneNav?: 'drawer' | 'none';
     /** Back-compat alias for nav="rail". Ignored when `nav` is set. */
     collapsed?: boolean;
     /**
@@ -3950,20 +6366,48 @@ interface AppShellProps extends HTMLAttributes<HTMLDivElement> {
     skipToContentLabel?: ReactNode;
     /** TENSOR RX-125 (UIX-04): translatable; English default. */
     exitFocusLabel?: ReactNode;
+    /** The phone menu button's name. Default: `UixLabelsProvider` `appShell.openNav`, then "Open navigation". */
+    openNavLabel?: string;
+    /** The navigation drawer's title. Default: `appShell.navigation`, then "Navigation". */
+    navigationLabel?: ReactNode;
 }
-declare function AppShell({ nav, collapsed, focus, onExitFocus, mainBleed, mainId, sidebar, topbar, children, skipToContentLabel: skipToContentLabelProp, exitFocusLabel: exitFocusLabelProp, className, ...props }: AppShellProps): react.JSX.Element;
+declare function AppShell({ layout, nav, defaultNav, onNavChange, navHotkey, navTierStorageKey, phoneNav: phoneNavProp, collapsed, focus, onExitFocus, mainBleed, mainId, sidebar, topbar, children, skipToContentLabel: skipToContentLabelProp, exitFocusLabel: exitFocusLabelProp, openNavLabel: openNavLabelProp, navigationLabel: navigationLabelProp, className, ...props }: AppShellProps): react.JSX.Element;
 
+/** The search row under the sidebar head (HAR-1371): it opens your search or command palette. */
+interface SidebarSearch {
+    /** The row's words, e.g. "Search". In the rail they are the button's name only. */
+    label: ReactNode;
+    /**
+     * The keys that open the same search, shown at the end of the row and given to assistive
+     * technology as `aria-keyshortcuts`, e.g. `['Mod', 'K']`. Showing them does not bind them:
+     * your command palette (or app) listens for the keys.
+     */
+    shortcut?: KeyShortcut;
+    onActivate: () => void;
+}
 interface SidebarProps extends HTMLAttributes<HTMLElement> {
     collapsed?: boolean;
     nav?: 'full' | 'rail';
     onToggle?: () => void;
     brand?: ReactNode;
     toggleIcon?: ReactNode;
+    /**
+     * Controls in the head beside the brand (HAR-1371): a mode toggle, a "…" utility `Menu`,
+     * collapse-all. Icon buttons (`Button icon size="sm"`) fit the row. Hidden in the rail.
+     */
+    actions?: ReactNode;
+    /** A search row under the head that opens your search (HAR-1371). */
+    search?: SidebarSearch;
+    /**
+     * A slot pinned to the bottom of the sidebar (HAR-1371), for an `AccountMenu`. In the rail it
+     * keeps what it renders; give an `AccountMenu` `collapsed` there.
+     */
+    footer?: ReactNode;
     children?: ReactNode;
     expandLabel?: string;
     collapseLabel?: string;
 }
-declare function Sidebar({ collapsed, nav, onToggle, brand, toggleIcon, children, expandLabel: expandLabelProp, collapseLabel: collapseLabelProp, className, ...props }: SidebarProps): react.JSX.Element;
+declare function Sidebar({ collapsed, nav, onToggle, brand, toggleIcon, actions, search, footer, children, expandLabel: expandLabelProp, collapseLabel: collapseLabelProp, className, ...props }: SidebarProps): react.JSX.Element;
 interface SidebarSectionProps {
     label?: string;
     children?: ReactNode;
@@ -3981,7 +6425,13 @@ interface NavItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     description?: ReactNode;
     children?: ReactNode;
 }
-declare function NavItem({ icon, badge, active, as: Tag, description, children, className, ...props }: NavItemProps): react.JSX.Element;
+/**
+ * One navigation row: a link (`as="a"`, default) or, for a row that acts in place (a mode toggle,
+ * an account menu), a `button`. The forwarded ref reaches the rendered `<a>` or `<button>`
+ * (HAR-1810), so a row can anchor a `Popover` (`anchor={ref}`); `popoverTarget` and other button
+ * attributes pass through with `as="button"`.
+ */
+declare const NavItem: react.ForwardRefExoticComponent<NavItemProps & react.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
 interface NavGroupProps {
     icon?: ReactNode;
     label: ReactNode;
@@ -3996,7 +6446,8 @@ interface SubNavItemProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
     as?: 'a' | 'button';
     children?: ReactNode;
 }
-declare function SubNavItem({ active, as: Tag, children, className, ...props }: SubNavItemProps): react.JSX.Element;
+/** A nested navigation row. Like `NavItem`, it forwards its ref to the `<a>` or `<button>` (HAR-1810). */
+declare const SubNavItem: react.ForwardRefExoticComponent<SubNavItemProps & react.RefAttributes<HTMLAnchorElement | HTMLButtonElement>>;
 
 interface StarButtonProps {
     /** Pinned state — drives the filled, warning-toned, always-visible look via `data-on`. */
@@ -4067,6 +6518,11 @@ interface NavFavouritesLabels {
     readonly remove: string;
     /** Per-row overflow-trigger accessible-name template with `{label}`. Defaults to "{label} favourite options". */
     readonly options?: string;
+    /**
+     * Polite announcement after a move: `{label}`, `{position}`, `{count}`. Defaults to
+     * "{label} moved to position {position} of {count}" (it was English only before HAR-1375).
+     */
+    readonly moved?: string;
 }
 interface NavFavouritesProps {
     /** The already-resolved favourites, in display order. */
@@ -4186,8 +6642,14 @@ interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
     accent?: boolean;
     /** Announced loading text (default "Loading…"). */
     label?: string;
+    /**
+     * Show the spinner only after it has been mounted this long: `true` is 300 ms, a number is
+     * milliseconds (HAR-2580). Work that ends sooner never flashes a spinner. To also hold it at
+     * least 500 ms once shown, mount it from `useDelayedPending(pending)` instead.
+     */
+    delay?: boolean | number;
 }
-declare function Spinner({ size, accent, label, className, ...props }: SpinnerProps): react.JSX.Element;
+declare function Spinner({ delay, ...props }: SpinnerProps): react.JSX.Element;
 
 type HeartbeatState = 'live' | 'idle' | 'warning' | 'danger';
 interface HeartbeatProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
@@ -4241,6 +6703,13 @@ interface ToastOptions {
      * Defaults: success/info/default 5 s, warning 8 s, error and loading stay.
      */
     duration?: number | null;
+    /**
+     * `false`: a fixed timer (HAR-1831). The toast closes `duration` after it appears, even while the
+     * pointer or focus is on it or the tab is hidden; for an undo window that must end on time
+     * (TENSOR's `useUndoableAction` commits after exactly 5 s). A toast waiting beyond the
+     * Toaster's `limit` starts its timer when it appears. Default `true`: the timer pauses.
+     */
+    pauseOnHover?: boolean;
     action?: ToastAction;
     /** Replaces the tone glyph. */
     icon?: ReactNode;
@@ -4253,6 +6722,8 @@ interface ToastRecord {
     message: ReactNode;
     description?: ReactNode;
     duration: number | null;
+    /** `false`: the timer does not pause (see {@link ToastOptions.pauseOnHover}). */
+    pauseOnHover?: boolean;
     action?: ToastAction;
     icon?: ReactNode;
     /** Set while the leave animation runs; the record is removed after it. */
@@ -4300,155 +6771,53 @@ interface ToastApi {
     promise: <T>(promise: Promise<T>, messages: ToastPromiseMessages<T>, options?: ToastOptions) => Promise<T>;
     /**
      * An optimistic action with an Undo button (TENSOR C2 `useUndoableAction`): `onCommit` runs
-     * when the toast closes without Undo; `onUndo` runs instead when Undo is pressed.
+     * when the toast closes without Undo; `onUndo` runs instead when Undo is pressed. Pass
+     * `pauseOnHover: false` for a commit that happens exactly `duration` after the toast appears.
      */
     undoable: (message: ReactNode, options: UndoableToastOptions) => string;
-    /** The store this API writes to; pass it to `<Toaster store>` for a non-default queue. */
-    store: ToastStore;
-}
-/** Binds the `toast()` API to a store. */
-declare function createToastApi(store: ToastStore): ToastApi;
-/** The default queue; a `<Toaster />` without a `store` prop renders it. */
-declare const toast: ToastApi;
-
-type ToastTone = 'success' | 'danger' | 'info' | 'warning';
-interface ToastProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
-    /** TENSOR RX-125 (UIX-04): translatable; English default. */
-    dismissLabel?: string;
-    title?: ReactNode;
-    message?: ReactNode;
-    tone?: ToastTone;
-    icon?: ReactNode;
-    /** A button (or link) after the text, e.g. "Undo" or "Copy details" (HAR-1363). */
-    action?: ReactNode;
-    onClose?: () => void;
-    leaving?: boolean;
-}
-declare function Toast({ title, message, tone, icon, action, onClose, leaving, dismissLabel: dismissLabelProp, className, ...props }: ToastProps): react.JSX.Element;
-interface ToasterProps extends HTMLAttributes<HTMLDivElement> {
-    /** TENSOR RX-125 (UIX-04): translatable; English default. */
-    regionLabel?: string;
-    /**
-     * The queue to render (HAR-1363). Default: the store behind the exported `toast()`.
-     * Children still render first, so a hand-managed `<Toast>` keeps working.
-     */
-    store?: ToastStore;
-    /** At most this many store toasts on screen; later ones wait their turn. Default 3. */
-    limit?: number;
-    /** Corner of the viewport. Default `bottom-end`. */
-    position?: 'bottom-end' | 'bottom-start' | 'bottom-center' | 'top-end' | 'top-start' | 'top-center';
-    children?: ReactNode;
-}
-declare function Toaster({ children, regionLabel: regionLabelProp, store, limit, position, className, onMouseEnter, onMouseLeave, onFocus, onBlur, onKeyDown, ...props }: ToasterProps): react.JSX.Element;
-
-interface TableWrapProps extends HTMLAttributes<HTMLDivElement> {
-    /**
-     * Polite live-region text for table state changes — "Sorted by …", "N results",
-     * "N selected". Pass `useTable().announcement` straight through (UIX-A11Y-2).
-     */
-    announcement?: string;
-    children?: ReactNode;
-}
-declare const TableWrap: react.ForwardRefExoticComponent<TableWrapProps & react.RefAttributes<HTMLDivElement>>;
-type TableDensity = 'compact' | 'standard' | 'comfortable';
-type SortDirection = 'ascending' | 'descending' | 'none';
-interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
-    density?: TableDensity;
-    zebra?: boolean;
-    pinnedCol?: boolean;
     /**
-     * Freeze the last column at the right edge while the wrap scrolls sideways, so a trailing
-     * row-actions column (peek, kebab) stays one click away. Pin the row's state with
-     * `Tr selected` / `Tr pinned`: the frozen cell repaints those, not a consumer's own row class.
+     * Undo an `undoable` toast from code, as if its Undo were pressed (HAR-1831): `onUndo` runs,
+     * `onCommit` does not, and the toast closes. Returns `false` when `id` is not an open undoable
+     * toast (it was already undone or committed). `dismiss(id)` commits instead.
      */
-    pinnedActions?: boolean;
-    /** table-layout: fixed — required for reliable column widths + primary-column truncation */
-    fixed?: boolean;
-    rowPeek?: boolean;
-    v2?: boolean;
-}
-declare function Table({ density, zebra, pinnedCol, pinnedActions, fixed, rowPeek, v2, className, children, ...props }: TableProps): react.JSX.Element;
-interface ThProps extends ThHTMLAttributes<HTMLTableCellElement> {
-    sortable?: boolean;
-    sortDirection?: SortDirection;
-    /** 1-based ordinal shown when this column is a secondary key in a multi-sort */
-    sortOrder?: number;
-    onSort?: () => void;
-}
-declare function Th({ sortable, sortDirection, sortOrder, onSort, className, children, onClick, ...props }: ThProps): react.JSX.Element;
-interface TdProps extends TdHTMLAttributes<HTMLTableCellElement> {
-    pinned?: boolean;
-}
-declare function Td({ pinned, className, children, ...props }: TdProps): react.JSX.Element;
-interface TrProps extends HTMLAttributes<HTMLTableRowElement> {
-    selected?: boolean;
-    pinned?: boolean;
-}
-declare function Tr({ selected, pinned, className, children, ...props }: TrProps): react.JSX.Element;
-interface BulkBarProps extends HTMLAttributes<HTMLDivElement> {
-    /** number of selected rows, rendered through `selectedLabel` */
-    count?: number;
-    children?: ReactNode;
-    /** TENSOR RX-125 (UIX-04): translatable; English default. */
-    label?: string;
-    /** TENSOR RX-125 (UIX-04): translatable; English default. */
-    selectedLabel?: (count: number) => ReactNode;
-}
-/** Contextual action bar shown above the table when ≥1 row is selected. */
-declare function BulkBar({ count, children, label, selectedLabel, className, ...props }: BulkBarProps): react.JSX.Element;
-interface RowActionsProps extends TdHTMLAttributes<HTMLTableCellElement> {
-    children?: ReactNode;
-}
-/** Trailing cell that holds the row's hover actions (kebab, quick actions). */
-declare function RowActions({ children, className, ...props }: RowActionsProps): react.JSX.Element;
-interface RowActionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    children?: ReactNode;
+    undo: (id: string) => boolean;
+    /** The store this API writes to; pass it to `<Toaster store>` for a non-default queue. */
+    store: ToastStore;
 }
-/** A single hover-revealed row action button (icon inside). */
-declare function RowAction({ children, className, type, ...props }: RowActionProps): react.JSX.Element;
-interface ExpandToggleProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    /** TENSOR RX-125 (UIX-04): translatable; English default. */
-    expandLabel?: string;
+/** Binds the `toast()` API to a store. */
+declare function createToastApi(store: ToastStore): ToastApi;
+/** The default queue; a `<Toaster />` without a `store` prop renders it. */
+declare const toast: ToastApi;
+
+type ToastTone = 'success' | 'danger' | 'info' | 'warning';
+interface ToastProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
     /** TENSOR RX-125 (UIX-04): translatable; English default. */
-    collapseLabel?: string;
-    expanded?: boolean;
-    /** id of the detail row this toggle controls → `aria-controls` (UIX-A11Y-2). */
-    controls?: string;
-}
-/** Chevron button that expands/collapses an inline detail row. */
-declare function ExpandToggle({ expanded, controls, expandLabel, collapseLabel, className, type, ...props }: ExpandToggleProps): react.JSX.Element;
-/** Emphasised primary cell text. */
-declare function CellStrong({ children, className, ...props }: HTMLAttributes<HTMLSpanElement>): react.JSX.Element;
-/** Secondary line under a primary cell value (muted, meta size). */
-declare function CellSub({ children, className, ...props }: HTMLAttributes<HTMLSpanElement>): react.JSX.Element;
-interface MarkProps extends HTMLAttributes<HTMLElement> {
-    children?: ReactNode;
-}
-/** A search-match highlight span. */
-declare function Mark({ children, className, ...props }: MarkProps): react.JSX.Element;
-interface HighlightedProps {
-    text: string;
-    query: string;
+    dismissLabel?: string;
+    title?: ReactNode;
+    message?: ReactNode;
+    tone?: ToastTone;
+    icon?: ReactNode;
+    /** A button (or link) after the text, e.g. "Undo" or "Copy details" (HAR-1363). */
+    action?: ReactNode;
+    onClose?: () => void;
+    leaving?: boolean;
 }
-/** Render `text` with case-insensitive matches of `query` wrapped in <mark>. */
-declare function Highlighted({ text, query }: HighlightedProps): react.JSX.Element;
-
-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;
+declare function Toast({ title, message, tone, icon, action, onClose, leaving, dismissLabel: dismissLabelProp, className, ...props }: ToastProps): react.JSX.Element;
+interface ToasterProps extends HTMLAttributes<HTMLDivElement> {
+    /** TENSOR RX-125 (UIX-04): translatable; English default. */
+    regionLabel?: string;
     /**
-     * `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).
+     * The queue to render (HAR-1363). Default: the store behind the exported `toast()`.
+     * Children still render first, so a hand-managed `<Toast>` keeps working.
      */
-    size?: PillSize;
-    dot?: boolean;
+    store?: ToastStore;
+    /** At most this many store toasts on screen; later ones wait their turn. Default 3. */
+    limit?: number;
+    /** Corner of the viewport. Default `bottom-end`. */
+    position?: 'bottom-end' | 'bottom-start' | 'bottom-center' | 'top-end' | 'top-start' | 'top-center';
     children?: ReactNode;
 }
-declare function StatusPill({ tone, treatment, size, dot, children, className, ...props }: StatusPillProps): react.JSX.Element;
+declare function Toaster({ children, regionLabel: regionLabelProp, store, limit, position, className, onMouseEnter, onMouseLeave, onFocus, onBlur, onKeyDown, ...props }: ToasterProps): react.JSX.Element;
 
 interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
     /** 0..max. Ignored when `indeterminate`. */
@@ -4482,8 +6851,15 @@ interface MeterProps extends HTMLAttributes<HTMLDivElement> {
 declare function Meter({ value, tone, label, toneLabels, className, ...props }: MeterProps): react.JSX.Element;
 
 interface StatTrend {
+    /** Which way the figure moved: the arrow, and the spoken "up" / "down". */
     direction: 'up' | 'down';
     label: ReactNode;
+    /**
+     * What the change means, which sets the colour (HAR-1563): `positive` green, `negative` red,
+     * `neutral` (default) grey. A rise in breached SLAs is `negative`; direction never picks the
+     * colour.
+     */
+    sentiment?: 'positive' | 'negative' | 'neutral';
 }
 interface StatProps extends HTMLAttributes<HTMLElement> {
     label: ReactNode;
@@ -4494,7 +6870,10 @@ interface StatProps extends HTMLAttributes<HTMLElement> {
     meta?: ReactNode;
     /** Trend chip rendered before the meta text. */
     trend?: StatTrend;
-    /** Outline and value colour. `neutral` (default) is today's tile. */
+    /**
+     * `warning` / `danger` colour the value and put a dot of that tone before it; the border stays
+     * neutral (HAR-1563). `neutral` (default) is the plain tile.
+     */
     tone?: 'neutral' | 'warning' | 'danger';
     /** `hero` (default) is today's KPI size; `compact` is for dense fact bands. */
     size?: 'hero' | 'compact';
@@ -4527,7 +6906,8 @@ interface StatProps extends HTMLAttributes<HTMLElement> {
     /**
      * Makes the whole tile a link (HAR-1350; TENSOR B7, MOTUS B-A7). Server-renderable, unlike
      * `onActivate`. Ignored when `onActivate` is set. The forwarded ref reaches the `<a>` only
-     * without `renderLink`.
+     * without `renderLink`. A trailing chevron in the label row marks the tile as a link at rest,
+     * since a touch screen has no hover (HAR-1803).
      */
     href?: string;
     /** The link tile is the current page (`aria-current="page"`). */
@@ -4540,6 +6920,20 @@ interface StatProps extends HTMLAttributes<HTMLElement> {
  * ref then points at that button, so a popover can anchor to it.
  */
 declare const Stat: react.ForwardRefExoticComponent<StatProps & react.RefAttributes<HTMLElement>>;
+interface StatRowProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * The narrowest a tile may get before the row puts fewer tiles side by side, as a CSS length
+     * (`--stat-row-min`). Default `8.5rem`, and `12rem` once a hero tile is in the row.
+     */
+    minTileWidth?: string;
+    children?: ReactNode;
+}
+/**
+ * A row of `Stat` tiles over `.uix-stat-row` (HAR-1803 review): as many tiles per row as fit at
+ * `minTileWidth`, all the same height, down to one per row on a phone. Use it instead of a fixed
+ * column count, which squeezes tiles until their labels break letter by letter.
+ */
+declare function StatRow({ minTileWidth, className, style, children, ...props }: StatRowProps): react.JSX.Element;
 
 type InsightStatusTone = 'ok' | 'warning' | 'critical' | 'unknown';
 interface InsightStatus {
@@ -4756,10 +7150,11 @@ interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'content'>
     placement?: Placement;
     /**
      * The trigger's keyboard shortcut, in `KbdCombo` key names, e.g. `['Mod', 'K']` (HAR-2031):
-     * shown with `Kbd` after the text, and set as the trigger's `aria-keyshortcuts` for the
-     * viewer's platform. Default: the `shortcut` of a `Button` child, so a Tooltip around a Button
-     * with a shortcut shows one bubble with the label and the keys. The kit only shows it: the
-     * product binds the key.
+     * shown with `Kbd` after the text. Screen readers hear it once, in the trigger's description
+     * after the text ("Keyboard shortcuts, Shift+?"), the same rule as a `Button` with `shortcut`
+     * (HAR-2416). Default: the `shortcut` of a `Button` child, so a Tooltip around a Button with a
+     * shortcut shows one bubble with the label and the keys. The kit only shows it: the product
+     * binds the key.
      */
     shortcut?: KeyShortcut;
     children?: ReactNode;
@@ -4771,6 +7166,9 @@ interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'content'>
  * (flip/shift), shown on hover and keyboard focus, dismissed on blur or Escape
  * (document-level, per WCAG 1.4.13), and hoverable: the bubble stays open while
  * the pointer is over it (UIX-A11Y-1).
+ *
+ * While the bubble is open it takes the first Escape (HAR-2415), also on a combobox-style trigger
+ * whose list is open (a Select, a date field): one Escape closes the bubble, the next one the list.
  */
 declare function Tooltip({ label, content, placement, shortcut, className, children, ...props }: TooltipProps): react.JSX.Element;
 
@@ -4848,9 +7246,15 @@ interface LoadingStateProps extends HTMLAttributes<HTMLDivElement> {
     density?: 'compact' | 'comfortable';
     /** Announced loading text (default "Loading"). */
     label?: string;
+    /**
+     * Show the skeleton only after it has been mounted this long: `true` is 300 ms, a number is
+     * milliseconds (HAR-2580). A first load that answers sooner goes straight to the content.
+     * Skeletons are for a first load; a refetch keeps its rows in a `BusyRegion`.
+     */
+    delay?: boolean | number;
 }
 /** A stack of skeleton rows for list/section loading. `role="status"`. */
-declare function LoadingState({ rows, density, label, className, ...props }: LoadingStateProps): react.JSX.Element;
+declare function LoadingState({ delay, ...props }: LoadingStateProps): react.JSX.Element;
 
 interface RelativeTimeFormatContext {
     date: Date;
@@ -4900,56 +7304,6 @@ interface LabelProps extends HTMLAttributes<HTMLSpanElement> {
 /** Colored label / tag over `.uix-label`. */
 declare function Label({ color, dot, children, className, style, ...props }: LabelProps): react.JSX.Element;
 
-/** Presence of a person (HAR-1374). Each state has its own shape as well as its own colour. */
-type AvatarPresence = 'online' | 'busy' | 'away' | 'offline';
-/** The words read for each presence state. English; pass translations as `presenceLabels`. */
-declare const DEFAULT_PRESENCE_LABELS: Record<AvatarPresence, string>;
-interface AvatarProps extends HTMLAttributes<HTMLSpanElement> {
-    /** TENSOR RX-125 (UIX-04): translatable; English default. Still honoured for `online`. */
-    onlineLabel?: string;
-    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
-    src?: string;
-    alt?: string;
-    /** Initials / fallback shown when there is no `src`. */
-    children?: ReactNode;
-    /** Online status dot. The same as `presence="online"`; kept for existing callers. */
-    status?: boolean;
-    /**
-     * A presence dot: `online` (filled green), `busy` (red with a bar), `away` (an amber ring),
-     * `offline` (a grey ring). The state is also in visually hidden text, so it is never colour
-     * alone.
-     */
-    presence?: AvatarPresence;
-    /** Translations of the presence words. */
-    presenceLabels?: Partial<Record<AvatarPresence, string>>;
-}
-/** Avatar over `.uix-avatar`. Renders an image when `src` is set, else children (initials). */
-declare function Avatar({ size, src, alt, children, status, presence, presenceLabels, onlineLabel, className, ...props }: AvatarProps): react.JSX.Element;
-interface PresenceDotProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
-    presence: AvatarPresence;
-    /**
-     * The state in words for assistive technology. Default: the English word. Pass `null` when
-     * the state is already written next to the dot, to make the dot decorative.
-     */
-    label?: string | null;
-}
-/** The presence dot on its own, for a row or a menu that shows no avatar (HAR-1374). */
-declare function PresenceDot({ presence, label, className, ...props }: PresenceDotProps): react.JSX.Element;
-interface AvatarGroupProps extends HTMLAttributes<HTMLSpanElement> {
-    children?: ReactNode;
-}
-/** Overlapping avatar stack over `.uix-avatar-group`. */
-declare function AvatarGroup({ children, className, ...props }: AvatarGroupProps): react.JSX.Element;
-interface UserChipProps extends HTMLAttributes<HTMLSpanElement> {
-    /** Usually an `<Avatar />`. */
-    avatar?: ReactNode;
-    name?: ReactNode;
-    /** Secondary line (role, email). */
-    sub?: ReactNode;
-}
-/** Avatar + name (+ optional sub-line) over `.uix-user-chip`. */
-declare function UserChip({ avatar, name, sub, className, children, ...props }: UserChipProps): react.JSX.Element;
-
 interface CommentsProps extends HTMLAttributes<HTMLDivElement> {
     children?: ReactNode;
 }
@@ -5003,6 +7357,12 @@ interface SaveStatusProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children
     labels?: Partial<SaveStatusLabels>;
     /** Offered as a button only while `state` is `failed`. */
     onRetry?: () => void;
+    /**
+     * Milliseconds before "Saving…" shows (default 300; HAR-2580). Until then the previous words
+     * stay, so a fast save goes straight to "Saved" without a flash; once "Saving…" shows it
+     * stays at least 500 ms. `0` shows every state at once and holds none.
+     */
+    delay?: number;
 }
 /**
  * Inline save feedback over `.uix-save-status`: saving → saved → failed, with a retry.
@@ -5014,7 +7374,67 @@ interface SaveStatusProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children
  * rendering null while idle would silence the first "Saving…". The retry button sits
  * outside the region so its label is not read out on every change.
  */
-declare function SaveStatus({ state, labels, onRetry, className, ...props }: SaveStatusProps): react.JSX.Element;
+declare function SaveStatus({ state, labels, onRetry, delay, className, ...props }: SaveStatusProps): react.JSX.Element;
+
+interface BusyRegionProps extends HTMLAttributes<HTMLDivElement> {
+    /** The content is being fetched again (a filter, sort, page or saved-view change). */
+    busy: boolean;
+    children?: ReactNode;
+}
+/**
+ * Keeps what is on screen while it is fetched again (HAR-2582, motion standard §2.5): the
+ * children stay, dim, and an indeterminate bar runs along the top; `aria-busy` is set at
+ * once. The bar and the dim wait 300 ms, so a quick refetch shows nothing, and then stay at
+ * least 500 ms. A skeleton is for a first load only: swapping rows for skeletons on every
+ * refetch hides what changed. For a table, `TableWrap refreshing` does the same.
+ */
+declare function BusyRegion({ busy, className, children, ...props }: BusyRegionProps): react.JSX.Element;
+
+interface ChangeHighlightProps extends HTMLAttributes<HTMLElement> {
+    /** The value shown inside. When it changes after mount the element flashes; never on the first render. */
+    value: unknown;
+    /** The element to render (default `span`): `td`, `tr`, `div`, `li`… A `tr` tints its cells. */
+    as?: keyof HTMLElementTagNameMap;
+    /**
+     * `tint` (default) fades a background tint, for a row, a cell or a field; `ring` fades an
+     * outline instead, for something with a colour of its own, such as a status pill.
+     */
+    variant?: 'tint' | 'ring';
+    /** Said politely when the value changes, e.g. "Status changed to Resolved by A. Novak". */
+    announce?: string;
+    /** No highlight, e.g. while the person is editing this value themselves. */
+    disabled?: boolean;
+    children?: ReactNode;
+}
+/**
+ * Shows that a value changed in place (HAR-2585, motion standard §2.5): a live update, the
+ * result of a transition, a rolled-back optimistic change. The element is tinted at once and
+ * the tint fades; under reduced motion or forced colours it is outlined for the same time
+ * instead. The flash is the signal and its place the location; pass `announce` for the
+ * description. For an element you render yourself, use `useChangeHighlight`; on plain markup,
+ * add `.uix-changed` (remove it, force a reflow and add it again to replay).
+ */
+declare const ChangeHighlight: react.ForwardRefExoticComponent<ChangeHighlightProps & react.RefAttributes<HTMLElement | null>>;
+
+interface CountProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    /** The number shown. */
+    value: number;
+    /**
+     * Formats the number, e.g. `n > 99 ? '99+' : String(n)` or your i18n formatter. The default is
+     * `toLocaleString()` in the runtime's locale: pass `format` when the server renders it, so the
+     * server's and the browser's thousands separators cannot differ.
+     */
+    format?: (value: number) => string;
+}
+/**
+ * A number that ticks once when it changes (HAR-2587, motion standard §2.8): a badge count, a
+ * stat tile's value, an unread total. The new figure slides 4 px in from below when it went
+ * up and from above when it went down, with a fade; never on the first render, never a loop,
+ * never a count-up through the numbers between. Tabular figures, so neighbours do not shift.
+ * Under reduced motion it only fades. It announces nothing: say what changed where it
+ * matters (a toast, `ChangeHighlight announce`).
+ */
+declare function Count({ value, format, className, ...props }: CountProps): react.JSX.Element;
 
 interface ComposerProps extends HTMLAttributes<HTMLDivElement> {
     children?: ReactNode;
@@ -5055,8 +7475,15 @@ interface SegmentedProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'
      * 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';
+     *
+     * `'link'` (HAR-1380): navigation, not a choice, such as a language switcher where each
+     * option is a URL. A `<nav>` (named by your `aria-label`) around a list of links, each
+     * option needs an `href`, and the one whose `value` is `value` carries `aria-current="page"`.
+     * The same pill look; every link is its own tab stop and Enter follows it, like any nav.
+     */
+    selection?: 'toggle' | 'radio' | 'link';
+    /** `selection="link"`: renders each option's link with your router. Default: `<a>`. */
+    renderLink?: UixRenderLink;
     children?: ReactNode;
 }
 /**
@@ -5070,9 +7497,13 @@ interface SegmentedProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'
  * 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, selection, children, className, onKeyDown, ...props }: SegmentedProps): react.JSX.Element;
+declare function Segmented({ value, onChange, selection, renderLink, children, className, onKeyDown, ...props }: SegmentedProps): react.JSX.Element;
 interface SegmentedOptionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'onChange'> {
     value: string;
+    /** In a `selection="link"` group: where the option goes. Required there, ignored otherwise. */
+    href?: string;
+    /** In a `selection="link"` group: the target's language, e.g. `de` on a locale switcher. */
+    hrefLang?: string;
     children?: ReactNode;
 }
 /**
@@ -5081,147 +7512,30 @@ interface SegmentedOptionProps extends Omit<ButtonHTMLAttributes<HTMLButtonEleme
  * `.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;
-
-interface ViewMenuColumn {
-    id: string;
+declare function SegmentedOption({ value, href, hrefLang, children, className, onClick, ...props }: SegmentedOptionProps): react.JSX.Element;
+interface LocaleSwitcherLocale {
+    /** BCP 47 code: `de`, `bs`, `en-GB`. Sets the link's `lang` and `hreflang`. */
+    code: string;
+    /** What the option shows: "Deutsch", or a short "DE". */
     label: ReactNode;
-    visible: boolean;
-    disabled?: boolean;
-    /** Always shown (e.g. the record id): the row has no checkbox and no Hide / Show, its name sits in the checkbox's slot. */
-    required?: boolean;
-    /** Plain-text name for the `{label}` templates in `columnLabels` when `label` is not a string. */
-    textLabel?: string;
-}
-/**
- * Words for the column rows. `{label}` is replaced by the column name; `moved` also gets
- * `{position}` and `{count}`. Every key has an English default.
- */
-interface ViewMenuColumnLabels {
-    /** Name of a row's ⋯ menu button and of the menu. Default `Column actions: {label}`. */
-    rowActions: string;
-    /** Name of a row's drag grip. Default `Drag to reorder: {label}`. */
-    reorder: string;
-    moveUp: string;
-    moveDown: string;
-    hide: string;
-    show: string;
-    /** Tooltip on a required column's name. Default `Always shown`. */
-    required: string;
-    /** Polite announcement after a move. Default `{label} moved to position {position} of {count}`. */
-    moved: string;
-}
-interface ViewMenuProps {
-    /** The density section renders when `densityOptions` and `onDensityChange` are given. */
-    density?: string;
-    densityLabel?: ReactNode;
-    densityOptions?: readonly {
-        value: string;
-        label: ReactNode;
-    }[];
-    onDensityChange?: (value: string) => void;
-    /** Optional title over the zebra / freeze switches. */
-    displayLabel?: ReactNode;
-    zebra?: {
-        checked: boolean;
-        label: ReactNode;
-        onChange: (checked: boolean) => void;
-    };
-    freeze?: {
-        checked: boolean;
-        label: ReactNode;
-        onChange: (checked: boolean) => void;
-    };
-    columns?: readonly ViewMenuColumn[];
-    columnsLabel?: ReactNode;
-    onColumnVisibilityChange?: (id: string, visible: boolean) => void;
-    /**
-     * Turns on reordering: every column row gets a drag grip (pointer; ArrowUp / ArrowDown once
-     * focused) and a ⋯ menu with Move up · Move down · Hide / Show, which is the keyboard path.
-     * Receives every column id, first to last. The order is the application's to persist.
-     */
-    onReorder?: (orderedIds: string[]) => void;
-    columnLabels?: Partial<ViewMenuColumnLabels>;
-    /** Pinned under the columns, e.g. a Reset sort `.uix-menu__item` button. */
-    footer?: ReactNode;
-    className?: string;
+    /** This page in that language. */
+    href: string;
 }
-/**
- * Controlled table presentation panel with its own surface: density, zebra / freeze and a column
- * list under sticky section titles. A column row is grip · checkbox · name · ⋯ (grip and ⋯ with
- * `onReorder`). Usable inside a Popover or any overlay shell, including one that adds no chrome.
- */
-declare function ViewMenu({ density, densityLabel, densityOptions, onDensityChange, displayLabel, zebra, freeze, columns, columnsLabel, onColumnVisibilityChange, onReorder, columnLabels, footer, className, }: ViewMenuProps): react.JSX.Element;
-interface FilterOption {
-    value: string;
+interface LocaleSwitcherProps extends Omit<HTMLAttributes<HTMLElement>, 'children' | 'onChange'> {
+    /** One link per language, in the order shown. */
+    locales: readonly LocaleSwitcherLocale[];
+    /** The code of the page's language; that link is `aria-current="page"`. */
+    current: string;
+    /** Names the navigation, in the page's language: "Language", "Sprache". */
     label: string;
+    /** Renders each link with your router (locale-aware links keep client navigation). */
+    renderLink?: UixRenderLink;
 }
-interface FilterPopoverProps {
-    label: ReactNode;
-    type?: 'text' | 'number' | 'date' | 'select' | 'enum' | 'boolean';
-    value: string;
-    onValueChange: (value: string) => void;
-    options?: readonly FilterOption[];
-    applyLabel: ReactNode;
-    clearLabel: ReactNode;
-    onApply: () => void;
-    onClear: () => void;
-    placeholder?: string;
-}
-/** Controlled filter editor content; applications own query serialization and the popover trigger. */
-declare function FilterPopover({ label, type, value, onValueChange, options, applyLabel, clearLabel, onApply, onClear, placeholder }: FilterPopoverProps): react.JSX.Element;
-interface SavedViewItem {
-    id: string;
-    label: ReactNode;
-    active?: boolean;
-    pinned?: boolean;
-}
-/** A titled group of saved views, e.g. the user's custom views above the built-in presets. */
-interface SavedViewSection {
-    id: string;
-    label: ReactNode;
-    items: readonly SavedViewItem[];
-}
-interface SavedViewMenuBaseProps {
-    onSelect: (id: string) => void;
-    emptyLabel?: ReactNode;
-    /** The row's overflow slot (e.g. a ⋯ menu trigger). It stays quiet until the row is hovered or focused, or its menu is open. */
-    actions?: (item: SavedViewItem) => ReactNode;
-    footer?: ReactNode;
-}
-type SavedViewMenuProps = SavedViewMenuBaseProps & ({
-    items: readonly SavedViewItem[];
-    sections?: never;
-} | {
-    sections: readonly SavedViewSection[];
-    items?: never;
-}) & ({
-    onPinChange: (id: string, pinned: boolean) => void;
-    pinLabel: string;
-    unpinLabel: string;
-} | {
-    onPinChange?: undefined;
-    pinLabel?: never;
-    unpinLabel?: never;
-}) & ({
-    /**
-     * Adds a drag grip to every row. Rows move only within their own section; the
-     * callback receives that section's full id order (and its id when `sections` is used).
-     * The grip also moves its row with ArrowUp / ArrowDown.
-     */
-    onReorder: (orderedIds: string[], sectionId: string | undefined) => void;
-    /** Accessible name of the grip; the row's name is attached as its description. */
-    reorderLabel: string;
-} | {
-    onReorder?: undefined;
-    reorderLabel?: never;
-});
 /**
- * Generic saved-view selector: optional titled sections inside one `.uix-menu`, rows of
- * grip · name · overflow. The selected row is tinted as a whole (no check glyph). Persistence,
- * ownership, permissions and labels remain application concerns.
+ * A language switcher (HAR-1380; MOTUS C-12): a `Segmented selection="link"` whose links carry
+ * `lang` and `hreflang`, so each language's name is read in that language.
  */
-declare function SavedViewMenu({ items, sections, onSelect, onPinChange, pinLabel, unpinLabel, onReorder, reorderLabel, emptyLabel, actions, footer }: SavedViewMenuProps): react.JSX.Element;
+declare function LocaleSwitcher({ locales, current, label, renderLink, ...props }: LocaleSwitcherProps): react.JSX.Element;
 
 interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
     children?: ReactNode;
@@ -5460,6 +7774,47 @@ interface MenuGroupProps {
 declare function MenuGroup({ label, children }: MenuGroupProps): react.JSX.Element;
 declare function MenuSeparator(): react.JSX.Element;
 
+/** One command of a `CommandPalette` in items mode. */
+interface CommandPaletteItem {
+    /** Unique among the items; also the option's id suffix. */
+    id: string;
+    label: string;
+    /** Group heading the item is listed under. Items without one form a group without a heading. */
+    group?: string;
+    /** More words that find the item but are not shown: synonyms, an old name, a record number. */
+    keywords?: readonly string[];
+    /** A second line, e.g. where the command leads. Not searched. */
+    description?: string;
+    /** Leading icon (decorative). */
+    icon?: ReactNode;
+    /** Key names (`['Mod', 'K']`) shown at the end of the row and set as `aria-keyshortcuts`. */
+    shortcut?: readonly string[];
+    /** Runs when the item is chosen. */
+    onSelect?: () => void;
+    /** Where the item leads: `onNavigate(href)`, else the browser goes there. */
+    href?: string;
+    /** Shown but not choosable; skipped by the arrow keys. */
+    disabled?: boolean;
+}
+/** A group of found commands, in the order they are shown. */
+interface CommandPaletteGroup {
+    /** The group heading; `undefined` for items without a group. */
+    label: string | undefined;
+    items: CommandPaletteItem[];
+}
+/**
+ * The commands `query` finds, best first (HAR-1378): a label that starts with the query, then
+ * labels where every word of the query starts a word, then labels that contain every word, then
+ * matches through `keywords`. Equal matches keep the order they were given in. An empty query
+ * finds every item, in order.
+ */
+declare function filterCommandItems(items: readonly CommandPaletteItem[], query: string): CommandPaletteItem[];
+/**
+ * `items` in groups, each group where its first item is, its items in their given order. With a
+ * ranked list (from `filterCommandItems`) the group of the best match comes first.
+ */
+declare function groupCommandItems(items: readonly CommandPaletteItem[]): CommandPaletteGroup[];
+
 interface CommandPaletteProps extends HTMLAttributes<HTMLDivElement> {
     /** TENSOR RX-125 (UIX-04): translatable; English default. */
     inputLabel?: string;
@@ -5471,6 +7826,40 @@ interface CommandPaletteProps extends HTMLAttributes<HTMLDivElement> {
     /** Props for the search input (value/onChange/placeholder wired by the consumer). */
     inputProps?: InputHTMLAttributes<HTMLInputElement>;
     children?: ReactNode;
+    /**
+     * Items mode (HAR-1378): pass the commands and the palette filters them itself (case and
+     * diacritics folded, best match first), groups them, moves the active one with ↑ / ↓ (Home / End
+     * while the query is empty) through `aria-activedescendant`, and runs it on Enter or a click.
+     * Without `items`, `children` render as before and the consumer wires everything.
+     */
+    items?: readonly CommandPaletteItem[];
+    /** Items mode: the query (controlled). Pair with `onQueryChange`. */
+    query?: string;
+    /** Items mode: the query as it changes (also when the palette clears it on close). */
+    onQueryChange?: (query: string) => void;
+    /** Items mode: what an empty query shows above all items, under the `recentLabel` heading. */
+    recent?: readonly CommandPaletteItem[];
+    /** Items mode: your own matching instead of the built-in one (`filterCommandItems`). */
+    filter?: (items: readonly CommandPaletteItem[], query: string) => CommandPaletteItem[];
+    /** Items mode: called with every chosen item, after its own `onSelect`, e.g. to record it as recent. */
+    onItemSelect?: (item: CommandPaletteItem) => void;
+    /** Items mode: follow an item's `href` with your router. Default: the browser goes there. */
+    onNavigate?: (href: string, item: CommandPaletteItem) => void;
+    /** Items mode: shown when nothing matches. Default: `UixLabelsProvider` `commandPalette.empty`, then "No results". */
+    emptyLabel?: ReactNode;
+    /** Items mode: the heading of `recent`. Default: `commandPalette.recent`, then "Recent". */
+    recentLabel?: string;
+    /** Items mode: the input's placeholder. */
+    placeholder?: string;
+    /**
+     * Items mode: host the palette in a modal native `<dialog>` (focus stays inside, Escape and a
+     * click outside close it, focus returns to the opener). Closing it clears the query. Without
+     * `open`, the palette renders in place.
+     */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Items mode: render at most this many found items (the count still says how many were found). Default 100. */
+    limit?: number;
 }
 /**
  * ⌘K command palette surface over `.uix-cmdk`. Presentational: mount it inside a
@@ -5482,7 +7871,7 @@ interface CommandPaletteProps extends HTMLAttributes<HTMLDivElement> {
  * popover it sits in `[data-uix-instant]`: it opens and closes with no animation, without the
  * consumer knowing the attribute (or the older `data-uix-cmdk-dialog`).
  */
-declare function CommandPalette({ inputProps, children, inputLabel: inputLabelProp, resultsLabel, className, ...props }: CommandPaletteProps): react.JSX.Element;
+declare function CommandPalette(props: CommandPaletteProps): react.JSX.Element;
 interface CommandGroupProps {
     label?: ReactNode;
     children?: ReactNode;
@@ -5655,9 +8044,16 @@ interface SectionHeadProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>
     helpLabel?: string;
     /** Right-aligned slot — a `.uix-section-link` anchor, a button, a pill. */
     action?: ReactNode;
+    /**
+     * `compact` is the in-card section preset (HAR-1815): a 15 px / 1.3 / 600 title in place of
+     * the 24 px editorial h2. Default `default`.
+     */
+    size?: 'default' | 'compact';
+    /** Heading level of the title. Default `h2`; an in-card section is often an `h3`. */
+    as?: 'h2' | 'h3';
 }
 /** Section head — title row (+ optional `help` ?) with an optional trailing action (`.uix-section-head`). */
-declare function SectionHead({ title, titleId, help, helpLabel, action, className, ...props }: SectionHeadProps): react.JSX.Element;
+declare function SectionHead({ title, titleId, help, helpLabel, action, size, as: Heading, className, ...props }: SectionHeadProps): react.JSX.Element;
 interface NoticeQueueProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
     /** Leading icon slot. */
     icon?: ReactNode;
@@ -5794,9 +8190,22 @@ interface EventRowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
     day: ReactNode;
     title: ReactNode;
     meta?: ReactNode;
+    /** Weekday above the month in the date tile, e.g. "Sri" (HAR-1370). */
+    weekday?: ReactNode;
+    /** Year under the day in the date tile, for a list that crosses a year (HAR-1370). */
+    year?: ReactNode;
+    /** Start time at the foot of the date tile, e.g. "18:00" (HAR-1370). */
+    time?: ReactNode;
+    /**
+     * The machine-readable date (and time) of the tile, e.g. `"2026-10-22T18:00+02:00"`: the tile
+     * becomes a `<time>` element, so the date is not only words.
+     */
+    dateTime?: string;
+    /** A thumbnail at the end of the row (an `<img>`), drawn 4:3 and cropped to fill (HAR-1370). */
+    media?: ReactNode;
 }
-/** Event row — date block + title/meta (`.uix-event-row`). */
-declare function EventRow({ month, day, title, meta, className, ...props }: EventRowProps): react.JSX.Element;
+/** Event row — date block + title/meta (`.uix-event-row`), with an optional thumbnail. */
+declare function EventRow({ month, day, title, meta, weekday, year, time, dateTime, media, className, ...props }: EventRowProps): react.JSX.Element;
 interface StatusRowProps extends HTMLAttributes<HTMLDivElement> {
     /** Leading indicator slot (e.g. a `.uix-dot`). */
     indicator?: ReactNode;
@@ -5902,11 +8311,63 @@ declare function joinDateTime(date: string | null, time: string, fallbackTime?:
 /** The short name of `timeZone` on that day ("CEST", "GMT+2"), for the label beside a time. */
 declare function timeZoneName(timeZone: string, date: string | null, locale?: string | readonly string[]): string;
 
+/**
+ * uix time-field model — pure helpers behind `TimePicker` (HAR-1835): how a locale writes a time
+ * of day, how a typed time is read, and how the arrow keys step it. No DOM, no React, no runtime
+ * import, so the unit test loads this file directly (time-field-model.test.mjs).
+ *
+ * A time is a wall-clock `HH:mm` string (what `<input type="time">` holds): 24-hour, zero-padded,
+ * no seconds, no zone.
+ */
+/** Whether `HH:mm` names a time of day (00:00 to 23:59). */
+declare function isValidTimeKey(value: string | null | undefined): value is string;
+/** Minutes since midnight of `HH:mm`. */
+declare const timeToMinutes: (value: string) => number;
+/** `HH:mm` of a minute of the day (wrapped into 0 … 1439). */
+declare const minutesToTime: (minutes: number) => string;
+/** Whether `locale` writes times on a 12-hour clock (en-US: yes; de, en-GB, bs: no). */
+declare function uses12Hour(locale?: string | readonly string[]): boolean;
+/** A time in the locale's own shape: 14:30 in German, 2:30 PM in en-US. `hour12` overrides the locale. */
+declare function formatTimeKey(value: string, locale?: string | readonly string[], hour12?: boolean): string;
+/**
+ * Where the hour and the minutes end in `formatTimeKey(value, locale, hour12)` (character offsets),
+ * found from the formatter's own parts, so "오후 2:30" (ko, the day period first) and "2:30 PM"
+ * both work. `null` when the value is not a time.
+ */
+declare function timePartEnds(value: string, locale?: string | readonly string[], hour12?: boolean): {
+    hour: number;
+    minute: number;
+} | null;
+/**
+ * Read a typed time. Accepts `14:30`, `14.30`, `14h30`, `1430`, `930`, `9` and, with a day period,
+ * `2:30 pm`, `2pm`, `2:30 p.m.` (and the locale's own words). Without a day period the hour is
+ * read on the 24-hour clock. Returns `HH:mm`, or `null` when the text is not a time.
+ */
+declare function parseTimeInput(text: string, locale?: string | readonly string[]): string | null;
+/** Whether `min` is after `max`: an overnight range (22:00 to 06:00) that wraps round midnight. */
+declare const isOvernightRange: (min?: string, max?: string) => boolean;
+/** Whether `value` is outside `min` / `max` (both `HH:mm`, inclusive; `min` after `max` wraps midnight). */
+declare function isTimeOutOfRange(value: string, min?: string, max?: string): boolean;
+/**
+ * The time `delta` minutes from `value`, for the arrow keys. Between `min` and `max` it stops at
+ * the ends; with neither it wraps round midnight. From an empty field it starts at `min`, or 00:00.
+ */
+declare function stepTime(value: string | null, delta: number, min?: string, max?: string): string;
+/** The times a list offers: every `step` minutes from `min` (or 00:00) to `max` (or 23:59). */
+declare function timeSlots(step: number, min?: string, max?: string): string[];
+
+/**
+ * A colour that a node or an edge shares with a legend item (HAR-1639). Colour is never the only
+ * signal: say the same thing in the node's text, the edge's `description` or its `variant`.
+ */
+type RelationshipGraphTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger' | 'accent';
 interface RelationshipGraphNode {
     id: string;
     label: string;
     type?: string;
     description?: string;
+    /** Layered layout: the node's border and edge mark take this tone (HAR-1639). */
+    tone?: RelationshipGraphTone;
     x?: number;
     y?: number;
     /** Layered layout: the node's column. Omitted → BFS distance from the root along source→target. */
@@ -5924,6 +8385,18 @@ interface RelationshipGraphEdge {
     arrow?: RelationshipGraphArrow;
     /** Layered layout: always draw this edge's label, whatever the label policy. */
     emphasis?: boolean;
+    /**
+     * `dashed` draws the line dashed, e.g. an expected relation that is missing (HAR-1639). Default
+     * `solid`; a lateral or cycle edge is dashed either way.
+     */
+    variant?: 'solid' | 'dashed';
+    /** The line and arrowhead take this tone (HAR-1639). */
+    tone?: RelationshipGraphTone;
+    /**
+     * Said to assistive technology with the relationship, on both nodes it joins, e.g. "expected,
+     * missing" (HAR-1639). The drawn line itself is decoration; the nodes carry the relationship.
+     */
+    description?: string;
 }
 interface PositionedRelationshipNode extends RelationshipGraphNode {
     x: number;
@@ -5939,7 +8412,12 @@ declare function boundRelationshipGraph(nodes: RelationshipGraphNode[], edges: R
 declare function relationshipNeighbors(nodeId: string, edges: RelationshipGraphEdge[]): string[];
 declare function layoutRelationshipGraph(nodes: RelationshipGraphNode[], edges: RelationshipGraphEdge[], rootId?: string): PositionedRelationshipNode[];
 declare function traverseRelationshipNode(nodes: RelationshipGraphNode[], currentId: string | undefined, direction: -1 | 1): string | undefined;
-type LayeredEdgeKind = 'forward' | 'lateral' | 'cycle';
+/**
+ * `forward` steps one column right; `skip` goes right across more than one column; `lateral`
+ * stays in its column; `back` goes left without closing a loop; `cycle` goes left and closes one
+ * (HAR-1639: only a cycle is flagged as one, and only lateral and cycle edges are dashed).
+ */
+type LayeredEdgeKind = 'forward' | 'skip' | 'lateral' | 'back' | 'cycle';
 interface LayeredLayoutOptions {
     rootId?: string;
     /** Minimum sibling group size that collapses into a cluster. Default 6; 0 disables. */
@@ -5974,7 +8452,7 @@ interface LayeredItem {
     children: string[];
     /** Set on the first member of an expanded cluster: the group its collapse control belongs to. */
     expandedGroup?: RelationshipGraphCluster;
-    /** True when a lateral or cycle edge touches this node. */
+    /** True when a cycle edge touches this node (HAR-1639: no longer set by skip, lateral or back edges). */
     inCycle: boolean;
     /** Edges (any kind) touching this item. */
     degree: number;
@@ -5991,6 +8469,10 @@ interface RoutedEdge {
     label?: string;
     arrow: RelationshipGraphArrow;
     emphasis: boolean;
+    /** The first underlying edge's `variant`, `tone` and `description`. */
+    variant: 'solid' | 'dashed';
+    tone?: RelationshipGraphTone;
+    description?: string;
     path: string;
     labelX: number;
     labelY: number;
@@ -6000,6 +8482,17 @@ interface RoutedEdge {
     arrowAngle: number;
     /** Label policy `auto` shows this label without interaction. */
     autoLabel: boolean;
+    /**
+     * The label is said once by the target column's header (`LayeredColumn.edgeLabel`), so the
+     * edge itself never draws it under `edgeLabels="auto"` (HAR-1387: 197 of 200 labels on a
+     * 300-node map read "depends on").
+     */
+    columnLabel: boolean;
+    /**
+     * One of a busy node's forward edges, drawn as a bus: along a shared trunk in the column gap
+     * and a short stub into the target, so a fan-out reads as one line, not a black fan (HAR-1387).
+     */
+    bus: boolean;
     /** The label wrapped to fit the column gap (at most two lines). */
     labelLines: string[];
 }
@@ -6008,6 +8501,11 @@ interface LayeredColumn {
     x: number;
     /** Underlying nodes in the column, cluster members included. */
     count: number;
+    /**
+     * The relation most forward edges into this column share, when the column takes more than a
+     * few of them: the header says it once and those edges draw no label (HAR-1387).
+     */
+    edgeLabel?: string;
 }
 interface LayeredLayout {
     rootId: string | undefined;
@@ -6039,6 +8537,37 @@ declare function classifyLayeredEdges(nodes: RelationshipGraphNode[], edges: Rel
 declare function clusterIdFor(parentId: string, type: string | undefined, edgeType: string | undefined): string;
 /** Layered, clustered, crossing-reduced layout for `RelationshipGraph layout="layered"`. */
 declare function layoutLayeredGraph(nodes: RelationshipGraphNode[], edges: RelationshipGraphEdge[], options?: LayeredLayoutOptions): LayeredLayout;
+/** An edge label's box on the stage, for `separateEdgeLabels`. */
+interface EdgeLabelBox {
+    id: string;
+    /** Centre of the label. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Where a label is drawn after `separateEdgeLabels`, or that it is left out. */
+interface PlacedEdgeLabel {
+    x: number;
+    y: number;
+    hidden: boolean;
+}
+/** The box a wrapped edge label takes, from its lines (the meta type size, as `wrapEdgeLabel` assumes). */
+declare function edgeLabelSize(lines: readonly string[]): {
+    width: number;
+    height: number;
+};
+/**
+ * Moves edge labels apart where they would be drawn over each other (HAR-1639: two labels on top
+ * of each other in a dense layered column). Labels are taken top to bottom; one that overlaps a
+ * label already placed moves down just below it. A label that would have to move further than
+ * `maxShift` from its edge is left out instead (the relationship is still in the nodes'
+ * descriptions and in the list). Deterministic: the same boxes give the same placement.
+ */
+declare function separateEdgeLabels(boxes: readonly EdgeLabelBox[], options?: {
+    gap?: number;
+    maxShift?: number;
+}): Map<string, PlacedEdgeLabel>;
 type LayeredNavigationKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight' | 'Home' | 'End';
 /** Keyboard traversal over a layered layout: ←/→ along forward edges, ↑/↓ within a column. */
 declare function layeredNeighbor(layout: LayeredLayout, currentId: string | undefined, key: LayeredNavigationKey): string | undefined;
@@ -6046,6 +8575,12 @@ declare function layeredNeighbor(layout: LayeredLayout, currentId: string | unde
 interface RelationshipGraphLegendItem {
     id: string;
     label: string;
+    /** Layered: the swatch takes the tone the matching nodes or edges take (HAR-1639). */
+    tone?: RelationshipGraphTone;
+    /** Layered: the swatch is a line (`edge`, default) or a node box (`node`). */
+    shape?: 'edge' | 'node';
+    /** Layered: a dashed line swatch for an edge `variant="dashed"`. */
+    variant?: 'solid' | 'dashed';
 }
 /** Every visible or announced string. Pass translations; English defaults fill the gaps. */
 interface RelationshipGraphLabels {
@@ -6078,7 +8613,17 @@ interface RelationshipGraphLabels {
     graphSummary: (nodes: number, edges: number) => string;
     relationship: string;
     conflict: string;
+    /** @deprecated No longer read: the list names a node's neighbours under `connectedHeading`. A
+     * `connectedTo` supplied without `connectedHeading` still sets that heading, from its words. */
     connectedTo: (names: string) => string;
+    /** The relationship list: the heading of a node's neighbours, e.g. "Connected to". */
+    connectedHeading: string;
+    /** The relationship list: shows every neighbour of a node with more than eight. */
+    showAllRelations: (count: number) => string;
+    /** The relationship list: back to the first eight neighbours. */
+    showFewerRelations: string;
+    /** Layered: ends a hub's description, which names only its first five relationships. */
+    moreRelations: (count: number, inList: boolean) => string;
     noConnections: string;
     expandNeighbors: string;
     openDetails: string;
@@ -6095,6 +8640,10 @@ interface RelationshipGraphLabels {
     retry: string;
     emptyTitle: string;
     emptyHint: string;
+    /** Layered: a node's outgoing relationship in its description (HAR-1639), e.g. "depends on Payments DB". */
+    relationTo: (relation: string, target: string) => string;
+    /** Layered: a node's incoming relationship in its description, e.g. "depends on, from Checkout". */
+    relationFrom: (relation: string, source: string) => string;
 }
 declare const DEFAULT_RELATIONSHIP_GRAPH_LABELS: RelationshipGraphLabels;
 interface RelationshipGraphProps {
@@ -6161,91 +8710,21 @@ interface RelationshipGraphProps {
     /** Layered: controlled roving focus. */
     focusId?: string;
     onFocusChange?: (id: string) => void;
+    /**
+     * Layered: brings this node into view without moving focus (HAR-1639), e.g. the row picked in
+     * a table beside the map while the keyboard stays in the table. Smooth, or at once with reduced
+     * motion. Changing it again scrolls again; `focusId` focuses as well.
+     */
+    revealId?: string;
+    /**
+     * Layered: draws the root with a heavier border. Default: when `rootId` is given. A map with
+     * several starting points (no `rootId`) has no one root, so nothing is marked (HAR-1639).
+     */
+    markRoot?: boolean;
 }
 /** Bounded, deterministic SVG relationship view with an equivalent accessible list. */
 declare function RelationshipGraph(props: RelationshipGraphProps): react.JSX.Element;
 
-interface MatchReviewField {
-    id: string;
-    label: string;
-    render?: (value: JsonValue | undefined, record: Record<string, JsonValue>) => ReactNode;
-}
-interface MatchReviewCandidate {
-    id: string;
-    record: Record<string, JsonValue>;
-    confidence?: number;
-    status?: 'pending' | 'resolved';
-    decision?: 'accepted' | 'dismissed' | 'split' | 'other';
-}
-type MatchReviewAction = 'accept' | 'dismiss' | 'split' | 'pick-other';
-interface MatchBulkResult {
-    succeeded: number;
-    failed?: number;
-}
-/**
- * Every word the match review renders or announces (TENSOR RX-125, UIX-12). Plural
- * pairs are `…One` / `…Many`; `{count}`, `{pending}`, `{total}`, `{id}` are placeholders.
- */
-interface MatchReviewLabels {
-    region: string;
-    loading: string;
-    retry: string;
-    empty: string;
-    emptyDetail: string;
-    pendingOf: string;
-    bulk: string;
-    selectedCount: string;
-    applying: string;
-    acceptSelected: string;
-    dismissSelected: string;
-    caption: string;
-    select: string;
-    confidence: string;
-    status: string;
-    actions: string;
-    selectCandidate: string;
-    notScored: string;
-    resolved: string;
-    pending: string;
-    decisionAccepted: string;
-    decisionDismissed: string;
-    decisionSplit: string;
-    decisionOther: string;
-    accept: string;
-    dismiss: string;
-    split: string;
-    pickOther: string;
-    acceptingOne: string;
-    acceptingMany: string;
-    dismissingOne: string;
-    dismissingMany: string;
-    acceptedOne: string;
-    acceptedMany: string;
-    dismissedOne: string;
-    dismissedMany: string;
-    failedSuffix: string;
-    bulkAcceptFailed: string;
-    bulkDismissFailed: string;
-}
-declare const DEFAULT_MATCH_REVIEW_LABELS: MatchReviewLabels;
-interface MatchReviewProps {
-    incoming: Record<string, JsonValue>;
-    incomingLabel?: string;
-    fields: MatchReviewField[];
-    candidates: MatchReviewCandidate[];
-    selectedIds?: Set<string>;
-    onSelectionChange?: (ids: Set<string>) => void;
-    onDecision: (candidateId: string, action: MatchReviewAction) => void;
-    onBulkDecision?: (candidateIds: string[], action: Extract<MatchReviewAction, 'accept' | 'dismiss'>) => void | MatchBulkResult | Promise<void | MatchBulkResult>;
-    loading?: boolean;
-    error?: string;
-    onRetry?: () => void;
-    className?: string;
-    labels?: Partial<MatchReviewLabels>;
-}
-/** Generic descriptor-driven incoming-record to candidate-match decision surface. */
-declare function MatchReview({ incoming, incomingLabel, fields, candidates, selectedIds, onSelectionChange, onDecision, onBulkDecision, loading, error, onRetry, className, labels: labelOverrides, }: MatchReviewProps): react.JSX.Element;
-
 interface MetricInputProps {
     value: number | null;
     onValueChange: (value: number | null) => void;
@@ -6363,84 +8842,6 @@ declare function BrandProfileEditor({ value, onChange, profiles, onSelectProfile
 /** Canonical Phase 46.9 export; equivalent to BrandProfileEditor. */
 declare const BrandProfiles: typeof BrandProfileEditor;
 
-type DiffKind = 'added' | 'removed' | 'changed' | 'conflicted';
-type DiffResolution = 'accept' | 'skip' | 'pending';
-interface DiffEntry {
-    path: string;
-    kind: DiffKind;
-    base?: JsonValue;
-    current?: JsonValue;
-    incoming?: JsonValue;
-}
-interface DiffSummary {
-    added: number;
-    removed: number;
-    changed: number;
-    conflicted: number;
-    resolved: number;
-    pending: number;
-}
-declare function buildThreeWayDiff(base: JsonValue | undefined, current: JsonValue | undefined, incoming: JsonValue | undefined, path?: string): DiffEntry[];
-declare function summarizeDiff(entries: DiffEntry[], resolutions?: Record<string, DiffResolution>): DiffSummary;
-
-/**
- * Every word the diff viewer renders (TENSOR RX-125, UIX-12). `base` / `current` /
- * `incoming` keep their meaning from before; `{path}`, `{version}`, `{resolved}` and
- * `{total}` are placeholders.
- *
- * `acceptIncomingFor` / `keepCurrentFor` / `markPendingFor` are the accessible names of
- * the three action buttons, so a screen reader hears which entry each one resolves. Keep
- * the visible word inside the translated name (WCAG 2.5.3 Label in Name): speech-input
- * users say what they see.
- */
-interface DiffViewerLabels {
-    base: string;
-    current: string;
-    incoming: string;
-    region: string;
-    summary: string;
-    noDifferences: string;
-    noDifferencesDetail: string;
-    conflicted: string;
-    changed: string;
-    added: string;
-    removed: string;
-    resolved: string;
-    pending: string;
-    valueFor: string;
-    resolve: string;
-    acceptIncoming: string;
-    keepCurrent: string;
-    markPending: string;
-    acceptIncomingFor: string;
-    keepCurrentFor: string;
-    markPendingFor: string;
-    resolutionAccept: string;
-    resolutionSkip: string;
-    resolutionPending: string;
-    notPresent: string;
-    progress: string;
-}
-declare const DEFAULT_DIFF_VIEWER_LABELS: DiffViewerLabels;
-interface DiffViewerProps {
-    base?: JsonValue;
-    current?: JsonValue;
-    incoming?: JsonValue;
-    entries?: DiffEntry[];
-    resolutions?: Record<string, DiffResolution>;
-    onResolutionChange?: (path: string, resolution: DiffResolution) => void;
-    labels?: Partial<DiffViewerLabels>;
-    /**
-     * Height of the resolution buttons and the entry disclosure rows. `sm` (the default) is
-     * the compact 28px kit size; `md` follows `--uix-control-h`, so a theme that sets its
-     * own control height (for example 60px touch targets) gets it here too; `lg` is 44px.
-     */
-    controlSize?: 'sm' | 'md' | 'lg';
-    className?: string;
-}
-/** Three-way configuration diff with per-entry keyboard-operable resolution. */
-declare function DiffViewer({ base, current, incoming, entries: providedEntries, resolutions: controlledResolutions, onResolutionChange, labels: labelOverrides, controlSize, className, }: DiffViewerProps): react.JSX.Element;
-
 /**
  * Every word the colour picker renders (TENSOR RX-125, UIX-12). `{label}`, `{color}`,
  * `{ratio}` and `{minimum}` are placeholders; `sample` is the contrast preview text.
@@ -6496,4 +8897,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, Attachment, type AttachmentLabels, AttachmentList, type AttachmentListProps, type AttachmentProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarPresence, 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, Bullet, type BulletProps, 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, DASHBOARD_CANVAS_COLUMNS, DAY, DEFAULT_ATTACHMENT_LABELS, DEFAULT_BRAND_PROFILE_EDITOR_LABELS, DEFAULT_BUILDER_CANVAS_LABELS, DEFAULT_COLOR_PICKER_LABELS, DEFAULT_DASHBOARD_CANVAS_LABELS, DEFAULT_DATE_PICKER_LABELS, DEFAULT_DATE_RANGE_PICKER_LABELS, DEFAULT_DATE_TIME_PICKER_LABELS, DEFAULT_DIFF_VIEWER_LABELS, DEFAULT_ENTITY_PICKER_LABELS, DEFAULT_FILE_UPLOAD_LABELS, DEFAULT_FILTER_EDITOR_LABELS, DEFAULT_FILTER_SUMMARY_LABELS, DEFAULT_INLINE_EDIT_LABELS, DEFAULT_INSIGHT_CARD_LABELS, DEFAULT_LIGHTBOX_LABELS, DEFAULT_MATCH_REVIEW_LABELS, DEFAULT_ORG_CHART_LABELS, DEFAULT_PAGINATION_LABELS, DEFAULT_PRESENCE_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, DEFAULT_TREE_LABELS, DashboardCanvas, type DashboardCanvasChange, type DashboardCanvasDirection, type DashboardCanvasGap, type DashboardCanvasItem, type DashboardCanvasLabels, type DashboardCanvasPlacement, type DashboardCanvasProps, type DashboardCanvasResize, DashboardGrid, type DashboardGridBreakpoint, type DashboardGridColumnCount, type DashboardGridColumns, type DashboardGridGap, DashboardGridItem, type DashboardGridItemProps, type DashboardGridProps, type DashboardGridSpan, type DateInputProblem, type DatePart, DatePicker, type DatePickerLabels, type DatePickerProps, DateRangePicker, type DateRangePickerLabels, type DateRangePickerProps, type DateRangeValue, DateTimePicker, type DateTimePickerLabels, type DateTimePickerProps, type DaySpanLayout, DescriptionItem, type DescriptionItemProps, DescriptionList, type DescriptionListItem, type DescriptionListProps, DetailLayout, type DetailLayoutProps, DetailPage, type DetailPageLinkProps, type DetailPageMetric, type DetailPageProps, type DetailPageTab, DialogClose, type DialogCloseEvent, type DialogCloseProps, type DiffEntry, type DiffKind, type DiffResolution, type DiffSummary, DiffViewer, type DiffViewerLabels, type DiffViewerProps, type DiscardPromptLabels, Drawer, type DrawerProps, EmptyState, type EmptyStateProps, EntityPicker, type EntityPickerLabels, type EntityPickerProps, type EntityPickerSearchResult, 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, InlineEdit, type InlineEditEditorProps, type InlineEditLabels, type InlineEditProps, Input, InputGroup, type InputGroupProps, type InputProps, InsightCard, type InsightCardLabels, type InsightCardProps, type InsightComparison, type InsightCoverage, type InsightKpi, type InsightStatus, type InsightStatusTone, type InsightTarget, type JsonPrimitive, type JsonValue, Kanban, KanbanCard, type KanbanCardProps, KanbanColumn, type KanbanColumnProps, type KanbanMoveDirection, type KanbanProps, Kbd, KbdCombo, type KbdComboProps, type KbdPlatform, type KbdProps, type KeyShortcut, Label, type LabelProps, type LaneCluster, type LaneInterval, type LanePlacement, type LayeredColumn, type LayeredEdgeClassification, type LayeredEdgeKind, type LayeredItem, type LayeredLayout, type LayeredLayoutOptions, type LayeredNavigationKey, type LayoutLaneOptions, 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, type MoveProposal, 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, OrgChart, type OrgChartLabels, type OrgChartNode, type OrgChartProps, 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 PlacedDaySpan, type PlacedMonthSpan, type PlacedSpan, Placement, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, type PositionedRelationshipNode, PresenceDot, type PresenceDotProps, type Primitive, Progress, type ProgressProps, PromptDialog, type PromptDialogProps, Prose, type ProseProps, Radio, RadioCard, type RadioCardProps, 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 SchedulingAgendaGroup, 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 SchedulingTimelineGroup, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps, SearchBar, type SearchBarLabels, type SearchBarProps, 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, TOP_LANE_CROSS_MIDNIGHT_MINUTES, 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, type TimeGridDayLayout, type TimeGridEntryContext, type TimeGridEntryInput, type TimeGridPart, type TimeGridSegment, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, type TimelineRange, type TimelineScale, type TimelineSpan, type TimelineSubTick, 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 TreeLabels, 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, ariaKeyShortcuts, boundRelationshipGraph, buildMonthGrid, buildThreeWayDiff, cachedDateTimeFormat, canvasItemLimits, canvasItemsOverlap, canvasMoveTarget, canvasReadingOrder, canvasResizeTarget, canvasRowCount, clampCanvasItem, clampMetricValue, clampWidth, classifyLayeredEdges, clusterIdFor, compactCanvas, contrastRatio, createToastApi, createToastStore, cx, dashboardGridClassName, dashboardGridItemClassName, dateOrder, datePattern, defaultTimelineStep, diffText, diffTokens, emptyFilterValue, enumerateDateKeys, enumerateDateSpan, fileKind, fileMatchesAccept, filterComboboxOptions, findRuleNodeDepth, flattenTree, foldForSearch, formatDateKey, formatFileSize, hexToRgb, highlightSegments, hsvToHex, hsvToRgb, isDateInRange, isDateUnavailable, isFilterEmpty, isRuleGroup, isValidDateKey, itemDaySpan, joinDateTime, layeredNeighbor, layoutDaySpans, layoutLane, layoutLayeredGraph, layoutMonthSpans, layoutRelationshipGraph, layoutTimeGridDay, mapRuleGroup, matchFilter, matchFilterPreset, meetsContrast, mergePinned, moveCanvasItem, moveRuleNode, multiSort, nextSortDir, normalizeCanvas, normalizeHex, orgChartInitials, orgChartZoomStep, packLanes, parseDateInput, parseDateValue, parseMetricValue, parseView, partitionFiles, pixelsToMs, placeCanvasItem, placeSpan, placesInTopLane, prefersReducedMotion, proposeMove, rankOverflow, relationshipNeighbors, relativeTimeValue, removeRuleNode, renderPlainLink, reorder, resizeCanvasItem, restoreBrandProfile, rgbToHex, rgbToHsv, ruleDepth, schedulingGridDays, searchRows, searchSegments, selectAllState, selectRangeDate, serializeView, setRuleCombinator, shiftSpan, shouldVirtualize, snapToStep, splitDateTime, startOfMonth, stepMetricValue, summarizeDiff, summarizeFilter, summarizeRule, textDiffRows, timeZoneName, timelineRepeatedHourOffset, timelineStepDelta, timelineSubTicks, timelineTicks, toDateKey, toast, toggleId, togglePage, toggleSort, tokenizeText, traverseRelationshipNode, treeNav, useAnchoredPosition, useDialog, useReducedMotion, useTable, useUixLabels, useVirtualRows, validateRuleDefinition, virtualWindow, wrapEdgeLabel, zonedDateKey, zonedDateSpan, zonedDayBounds, zonedDaySpan, zonedHourSlots, zonedTimeOfDay };
+export { type AccessStateProps, AccountMenu, type AccountMenuLabels, type AccountMenuProps, type AccountMenuUser, Alert, type AlertProps, type AlertTone, AppShell, type AppShellProps, type AppliedBrandProfileSnapshot, type AsyncOperationState, AsyncOperationStatus, type AsyncOperationStatusProps, Attachment, type AttachmentLabels, AttachmentList, type AttachmentListProps, type AttachmentProps, AuditLog, type AuditLogAction, type AuditLogEvent, type AuditLogFilters, type AuditLogLabels, type AuditLogProps, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarPresence, 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, Bullet, type BulletProps, BusyRegion, type BusyRegionProps, Button, ButtonGroup, type ButtonGroupProps, ButtonLink, type ButtonLinkProps, type ButtonProps, type ButtonResult, type ButtonResultLabels, type ButtonSize, type ButtonVariant, type CalendarDay, type CalendarWeekday, Card, CardLink, type CardLinkProps, type CardProps, CellStrong, CellSub, type CellSubProps, ChangeHighlight, type ChangeHighlightOptions, type ChangeHighlightProps, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, Chip, ChipGroup, type ChipGroupProps, type ChipProps, CodeDisplay, type CodeDisplayLabels, type CodeDisplayProps, CollapsibleSection, type CollapsibleSectionProps, ColorPicker, type ColorPickerLabels, type ColorPickerProps, type ColumnFilter, Combobox, type ComboboxGroup, type ComboboxOption, type ComboboxProps, CommandGroup, type CommandGroupProps, CommandItem, type CommandItemProps, CommandPalette, type CommandPaletteGroup, type CommandPaletteItem, type CommandPaletteProps, Comment, type CommentProps, Comments, type CommentsProps, Composer, ComposerBar, type ComposerBarProps, type ComposerProps, type ConfirmButtonProps, ConfirmDialog, type ConfirmDialogProps, ContactCard, type ContactCardLabels, type ContactCardProps, type ContactCardState, ContentList, ContentListItem, type ContentListItemProps, type ContentListProps, type ContrastPreference, CopyButton, type CopyButtonProps, Count, type CountProps, DASHBOARD_CANVAS_COLUMNS, DATE_FILTER_OPERATORS, DAY, DEFAULT_ACCOUNT_MENU_LABELS, DEFAULT_ATTACHMENT_LABELS, DEFAULT_AUDIT_LOG_LABELS, DEFAULT_BRAND_PROFILE_EDITOR_LABELS, DEFAULT_BUILDER_CANVAS_LABELS, DEFAULT_BUTTON_RESULT_LABELS, DEFAULT_CODE_DISPLAY_LABELS, DEFAULT_COLOR_PICKER_LABELS, DEFAULT_CONTACT_CARD_LABELS, DEFAULT_DASHBOARD_CANVAS_LABELS, DEFAULT_DATA_WORKSPACE_LABELS, DEFAULT_DATE_PICKER_LABELS, DEFAULT_DATE_RANGE_PICKER_LABELS, DEFAULT_DATE_TIME_PICKER_LABELS, DEFAULT_DIFF_VIEWER_LABELS, DEFAULT_DISPLAY_PREFERENCES, DEFAULT_DISPLAY_PREFERENCES_LABELS, DEFAULT_ENTITY_PICKER_LABELS, DEFAULT_FILE_UPLOAD_LABELS, DEFAULT_FILTER_EDITOR_LABELS, DEFAULT_FILTER_SUMMARY_LABELS, DEFAULT_INLINE_EDIT_LABELS, DEFAULT_INSIGHT_CARD_LABELS, DEFAULT_LIGHTBOX_LABELS, DEFAULT_MATCH_REVIEW_LABELS, DEFAULT_ORG_CHART_LABELS, DEFAULT_PAGINATION_LABELS, DEFAULT_PASSWORD_INPUT_LABELS, DEFAULT_PRESENCE_LABELS, DEFAULT_PRINT_LAYOUT_LABELS, DEFAULT_QR_CODE_LABELS, DEFAULT_QR_SCANNER_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_SORTABLE_LIST_LABELS, DEFAULT_STEP_STATE_LABELS, DEFAULT_TAG_INPUT_LABELS, DEFAULT_TEXT_DIFF_LABELS, DEFAULT_TIME_PICKER_LABELS, DEFAULT_TREE_LABELS, DISPLAY_PREFERENCES_STORAGE_KEY, DISPLAY_PREFERENCE_OPTIONS, DashboardCanvas, type DashboardCanvasChange, type DashboardCanvasDirection, type DashboardCanvasGap, type DashboardCanvasItem, type DashboardCanvasLabels, type DashboardCanvasPlacement, type DashboardCanvasProps, type DashboardCanvasResize, DashboardGrid, type DashboardGridBreakpoint, type DashboardGridColumnCount, type DashboardGridColumns, type DashboardGridGap, DashboardGridItem, type DashboardGridItemProps, type DashboardGridProps, type DashboardGridSpan, DataWorkspace, type DataWorkspaceColumn, type DataWorkspaceIdColumn, type DataWorkspaceLabels, type DataWorkspacePagination, type DataWorkspaceProps, type DataWorkspaceSort, type DateFilterOperator, type DateInputProblem, type DatePart, DatePicker, type DatePickerLabels, type DatePickerProps, DateRangePicker, type DateRangePickerLabels, type DateRangePickerProps, type DateRangeValue, DateTimePicker, type DateTimePickerLabels, type DateTimePickerProps, type DaySpanLayout, type DelayedPendingOptions, type DensityPreference, DescriptionItem, type DescriptionItemProps, DescriptionList, type DescriptionListItem, type DescriptionListProps, DetailLayout, type DetailLayoutProps, DetailPage, type DetailPageLinkProps, type DetailPageMetric, type DetailPageProps, type DetailPageTab, DialogClose, type DialogCloseEvent, type DialogCloseProps, type DiffEntry, type DiffKind, type DiffResolution, type DiffSide, type DiffSummary, DiffViewer, type DiffViewerLabels, type DiffViewerProps, type DiscardPromptLabels, type DisplayAttributes, type DisplayPreferenceValues, DisplayPreferences, type DisplayPreferencesLabels, type DisplayPreferencesProps, Drawer, type DrawerProps, type EdgeLabelBox, EmptyState, type EmptyStateProps, EntityPicker, type EntityPickerLabels, type EntityPickerProps, type EntityPickerSearchError, type EntityPickerSearchResult, 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, InlineEdit, type InlineEditEditorProps, type InlineEditErrorContext, type InlineEditLabels, type InlineEditProps, type InlineEditState, Input, InputGroup, type InputGroupProps, type InputProps, Inset, type InsetProps, InsightCard, type InsightCardLabels, type InsightCardProps, type InsightComparison, type InsightCoverage, type InsightKpi, type InsightStatus, type InsightStatusTone, type InsightTarget, type JsonPrimitive, type JsonValue, Kanban, KanbanCard, type KanbanCardProps, KanbanColumn, type KanbanColumnProps, type KanbanMoveDirection, type KanbanProps, Kbd, KbdCombo, type KbdComboProps, type KbdPlatform, type KbdProps, type KeyShortcut, Label, type LabelProps, type LaneCluster, type LaneInterval, type LanePlacement, type LayeredColumn, type LayeredEdgeClassification, type LayeredEdgeKind, type LayeredItem, type LayeredLayout, type LayeredLayoutOptions, type LayeredNavigationKey, type LayoutLaneOptions, type LayoutMonthSpansOptions, LicensePositionBar, type LicensePositionBarProps, Lightbox, type LightboxItem, type LightboxLabels, type LightboxOverlayContext, type LightboxProps, List, ListItem, type ListItemProps, type ListProps, LiveIndicator, type LiveIndicatorProps, LoadingState, type LoadingStateProps, LocaleSwitcher, type LocaleSwitcherLocale, type LocaleSwitcherProps, 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, type MotionPreference, type MoveProposal, 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 OptimisticRollback, OrgChart, type OrgChartLabels, type OrgChartNode, type OrgChartProps, OtpInput, type OtpInputProps, PENDING_DELAY_MS, PENDING_MIN_VISIBLE_MS, type PackLanesOptions, type PackedLanes, PageHeader, type PageHeaderProps, PageIntro, type PageIntroProps, Pagination, type PaginationLabels, type PaginationProps, PasswordInput, type PasswordInputLabels, type PasswordInputProps, Peek, type PeekProps, type PillSize, type PillTone, type PillTreatment, Pipeline, type PipelineProps, PipelineStage, type PipelineStageProps, type PipelineStageState, type PlacedDaySpan, type PlacedEdgeLabel, type PlacedMonthSpan, type PlacedSpan, Placement, Popconfirm, type PopconfirmProps, Popover, type PopoverProps, type PositionedRelationshipNode, PresenceDot, type PresenceDotProps, type Primitive, PrintLayout, type PrintLayoutLabels, type PrintLayoutProps, PrintPageBreak, type PrintPageSize, PrintSignature, type PrintSignatureProps, Progress, type ProgressProps, PromptDialog, type PromptDialogProps, Prose, type ProseProps, QrCapacityError, QrCode, type QrCodeLabels, type QrCodeProps, type QrEncodeOptions, type QrErrorCorrection, type QrMatrix, QrScanner, type QrScannerDecoder, type QrScannerFrame, type QrScannerLabels, type QrScannerProps, type QrScannerStatus, RESULT_HOLD_MS, Radio, RadioCard, type RadioCardProps, 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, type RelationshipGraphTone, RelativeTime, type RelativeTimeFormatContext, type RelativeTimeProps, type RelativeTimeUnit, type RelativeTimeValue, type ResourceDayItem, type ResourceDaySlot, type ResourceDaySlotOptions, 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 SchedulingAgendaGroup, type SchedulingAvailabilityKind, 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 SchedulingResource, type SchedulingResourceSpan, type SchedulingSlotSelection, type SchedulingStatus, SchedulingTimeline, type SchedulingTimelineGroup, type SchedulingTimelineItem, type SchedulingTimelineLabels, type SchedulingTimelineLane, type SchedulingTimelineMarker, type SchedulingTimelineOverlay, type SchedulingTimelineOverlayKind, type SchedulingTimelineProps, SearchBar, type SearchBarLabels, type SearchBarProps, 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, type SidebarSearch, SidebarSection, type SidebarSectionProps, Skeleton, type SkeletonProps, type SortDir, type SortDirection, type SortKey, SortableList, type SortableListItemContext, type SortableListLabels, type SortableListProps, Spinner, type SpinnerProps, StarButton, type StarButtonProps, Stat, StatLine, type StatLineItem, type StatLineProps, type StatProps, StatRow, type StatRowProps, 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, type SystemDisplayPreferences, TEXT_FILTER_OPERATORS, TOAST_LEAVE_MS, TOP_LANE_CROSS_MIDNIGHT_MINUTES, Tab, TabPanel, type TabPanelProps, type TabProps, Table, type TableDensity, type TableProps, TableWrap, type TableWrapProps, Tabs, type TabsProps, TagInput, type TagInputLabels, type TagInputProps, Td, type TdProps, TextDiff, type TextDiffGranularity, type TextDiffLabels, type TextDiffLine, type TextDiffOp, type TextDiffOptions, type TextDiffProps, type TextDiffResult, type TextDiffRow, type TextDiffSegment, type TextFilterOperator, type TextScalePreference, Textarea, type TextareaProps, Th, type ThProps, type ThemePreference, ThemeSwitcher, type ThemeSwitcherProps, type TimeGridDayLayout, type TimeGridEntryContext, type TimeGridEntryInput, type TimeGridPart, type TimeGridSegment, type TimeInputProblem, TimePicker, type TimePickerLabels, type TimePickerProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, type TimelineRange, type TimelineScale, type TimelineSpan, type TimelineSubTick, 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 TreeLabels, type TreeLike, type TreeNavAction, type TreeNodeData, type TreeNodeProps, type TreeProps, type UixDateFormat, type UixLabels, UixLabelsProvider, type UixLabelsProviderProps, type UixLinkProps, type UixRenderLink, type UndoableToastOptions, type UseAnchoredPositionOptions, type UseDisplayPreferencesOptions, type UseDisplayPreferencesResult, type UseOptimisticValueOptions, type UseOptimisticValueResult, 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, accountInitials, addCalendarDays, addCalendarMonths, addZonedDays, announcePolite, appendRuleNode, applyBrandProfile, applyDisplayAttributes, applyFilters, ariaKeyShortcuts, boundRelationshipGraph, buildMonthGrid, buildThreeWayDiff, cachedDateTimeFormat, canvasItemLimits, canvasItemsOverlap, canvasMoveTarget, canvasReadingOrder, canvasResizeTarget, canvasRowCount, clampCanvasItem, clampMetricValue, clampWidth, classifyLayeredEdges, clusterIdFor, codeGroups, compactCanvas, contrastRatio, createToastApi, createToastStore, cx, dashboardGridClassName, dashboardGridItemClassName, dateFilterBounds, dateOrder, datePattern, defaultTimelineStep, diffText, diffTokens, displayPreferencesScript, edgeLabelSize, emptyFilterValue, encodeQr, enumerateDateKeys, enumerateDateSpan, fileKind, fileMatchesAccept, filterComboboxItems, filterComboboxOptions, filterCommandItems, findRuleNodeDepth, flashChanged, flattenTree, foldForSearch, formatCountdown, formatDateKey, formatFileSize, formatTimeKey, groupCommandItems, hexToRgb, highlightSegments, hsvToHex, hsvToRgb, isDateInRange, isDateUnavailable, isFilterEmpty, isOvernightRange, isRuleGroup, isTimeOutOfRange, isUnresolvedChoice, isValidDateKey, isValidTimeKey, itemDaySpan, joinDateTime, layeredNeighbor, layoutDaySpans, layoutLane, layoutLayeredGraph, layoutMonthSpans, layoutRelationshipGraph, layoutResourceColumn, layoutTimeGridDay, mapRuleGroup, matchFilter, matchFilterPreset, meetsContrast, mergePinned, minutesToTime, moveCanvasItem, moveRuleNode, multiSort, nextSortDir, normalizeCanvas, normalizeHex, orgChartInitials, orgChartZoomStep, packLanes, parseDateInput, parseDateValue, parseDisplayPreferences, parseMetricValue, parseTimeInput, parseView, partitionFiles, pixelsToMs, placeCanvasItem, placeId, placeSpan, placesInTopLane, prefersReducedMotion, proposeMove, qrDataCapacity, qrPath, qrVersionFor, rankOverflow, readSystemDisplayPreferences, relationshipNeighbors, relativeTimeValue, removeRuleNode, renderPlainLink, reorder, resizeCanvasItem, resolveDisplayAttributes, resolveFilterLabels, resourceDayGaps, resourceDaySlots, restoreBrandProfile, rgbToHex, rgbToHsv, ruleDepth, schedulingGridDays, searchRows, searchSegments, selectAllState, selectRangeDate, separateEdgeLabels, serializeView, setRuleCombinator, shiftSpan, shouldVirtualize, snapToStep, splitDateTime, startOfMonth, stepMetricValue, stepTime, summarizeDiff, summarizeFilter, summarizeRule, telHref, textDiffRows, timePartEnds, timeSlots, timeToMinutes, timeZoneName, timelineRepeatedHourOffset, timelineStepDelta, timelineSubTicks, timelineTicks, toDateKey, toast, toggleId, togglePage, toggleSort, tokenizeText, traverseRelationshipNode, treeNav, useAnchoredPosition, useChangeHighlight, useDelayedPending, useDialog, useDisplayPreferences, useOptimisticValue, useReducedMotion, useTable, useUixLabels, useVirtualRows, uses12Hour, validateRuleDefinition, virtualWindow, wrapEdgeLabel, zonedDateKey, zonedDateSpan, zonedDayBounds, zonedDaySpan, zonedHourSlots, zonedTimeOfDay };