@forgeroute/ui 0.4.71 → 0.4.73

package/types/forgeroute-ui.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from "@angular/core";
-import { EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, WritableSignal } from "@angular/core";
+import { AfterContentChecked, EnvironmentProviders, InjectionToken, OnDestroy, OnInit, Signal, TemplateRef, WritableSignal } from "@angular/core";
 import { UrlTree } from "@angular/router";
 import { Observable, Subject } from "rxjs";
 import { AbstractControl, ControlValueAccessor, FormControl, ValidationErrors, Validator, ValidatorFn } from "@angular/forms";
@@ -356,6 +356,34 @@ export type BulkUpdateOption<T = any> = string | {
    * else "N <itemLabel>(s) <doneLabel>.". Default 'updated'.
    */
   doneLabel?: string;
+  /**
+   * Direct action only: the request returns a FILE instead of JSON (a ZIP of PDFs, a CSV...). The table still confirms first and POSTs
+   * `<endpoint>/bulk/<field>` with exactly `{ ids }`, but asks for a blob response and saves it as one download (one file, so browsers do not
+   * block it the way several automatic downloads are blocked). The file name is the response's `Content-Disposition` filename, else
+   * `fileName`, else the action key. The toast reads "N <itemLabel>(s) <doneLabel>." (`doneLabel` defaults to 'downloaded' here); the server may
+   * send an `X-Skipped-Count` header with the number of selected rows it left out of the file ("N downloaded, M skipped."). The rows do not change,
+   * so the table is not refreshed; the selection is cleared and `(bulkAction)` is emitted. An error response is read as `{ message }` JSON and shown
+   * in an error toast. Omit it and the action expects JSON as before.
+   *
+   *   { field: 'download-pdfs', action: true, label: 'Download PDFs', download: { fileName: 'inspections.zip' } }
+   */
+  download?: {
+    fileName?: string;
+  };
+  /**
+   * Direct action only (`opens: 'panel'`): the button does not confirm and does not POST. It emits `(bulkPanelClick)` with the
+   * eligible rows and the host opens its own panel or form (compose an e-mail, add a charge...) and does the work itself.
+   * The host calls `clearSelection()` and `refresh()` on the table when it is done. `confirm` and `doneLabel` are ignored for a panel action (no confirm is shown; `variant: 'danger'` still colours the button); `eligible` still applies (refused rows are never passed on). Omit it and nothing changes.
+   *
+   *   { field: 'email', action: true, opens: 'panel', label: 'Email', eligible: (r: Resident) => !!r.email }
+   */
+  opens?: 'panel';
+  /**
+   * Panel action only (`opens: 'panel'`): true while the action is not available right now (e.g. text messaging is switched off). The button is
+   * then not shown at all. Read every time the bar renders, so it can read signals; a function that throws counts as "not hidden". A panel
+   * action is also not shown while none of the selected rows is `eligible`. Omit it and the button shows whenever a selected row is eligible.
+   */
+  hidden?: () => boolean;
 };
 /** What a bulk confirm function receives. For a direct bulk action: `columnLabel` is the action label, `targetValue`/`targetLabel` are '', `rows`/`skippedRows` the eligible / refused selected rows. For bulk Delete: `targetValue`/`targetLabel` are '', `columnLabel` is 'Delete', skipped counts are 0. */
 export interface BulkConfirmContext<T = any> {
@@ -423,6 +451,14 @@ export interface BulkActionDef {
   eligible?: (row: any) => boolean;
   /** Direct action: past-tense word in the result toast (from `{ doneLabel }`), default 'updated'. */
   doneLabel?: string;
+  /** Direct action that returns a file (from `{ download }`): the response is saved as a download instead of read as JSON. */
+  download?: {
+    fileName?: string;
+  };
+  /** True for a direct action that opens a host panel instead of confirming and POSTing (from `{ opens: 'panel' }`). */
+  opensPanel?: boolean;
+  /** Panel action: true while it is not available (from `{ hidden }`); the button is not shown. */
+  hidden?: () => boolean;
   /**
    * The item field this action targets (e.g. 'status', 'type').
    * When set the table shows an inline select populated from the column's option sources.
@@ -437,6 +473,19 @@ export interface BulkActionEvent {
   value?: string;
   skippedCount: number;
 }
+/** Emitted by (bulkPanelClick) when the user clicks a bulk action declared with `opens: 'panel'`. */
+export interface BulkPanelEvent<T = any> {
+  /** `action-<key>` of the clicked bulk option. */
+  type: string;
+  /** The option's `field` (its key), e.g. 'email'. */
+  key: string;
+  /** Ids of the eligible selected rows. */
+  ids: string[];
+  /** The eligible selected rows (loaded page). */
+  rows: T[];
+  /** Selected rows the option's `eligible` refused. */
+  skippedCount: number;
+}
 /** Emitted by (rowReorder) after the user moves a row (`reorderable`). */
 export interface TableRowReorderEvent<T = any> {
   /** The row that was moved. */
@@ -1084,6 +1133,15 @@ export declare class SelectComponent implements ControlValueAccessor, Validator,
   readonly label: import("@angular/core").InputSignal<string>;
   /** Accessible name for a select with no visible label (e.g. an inline row or table-cell select). */
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /**
+   * Compact, label-less look for a filter above KPI cards or in a toolbar (library source 2026-11-04, not yet published). `true` renders NO visible
+   * label row (no gap above the field; the `*` marker goes with it) while `label` stays the select's accessible name through `aria-label` and still
+   * words the built-in "<label> is required." message. An explicit `ariaLabel` wins over `label`. Default `false` = unchanged. Combine with
+   * `size="sm"`. (`ariaLabel` alone, with no `label`, was already the way to name a label-less select in a table cell.)
+   */
+  readonly labelHidden: import("@angular/core").InputSignal<boolean>;
+  /** Native `name` attribute placed on the inner `<select>` (e2e `[name=x]` selectors, autofill). None when empty. */
+  readonly inputName: import("@angular/core").InputSignal<string>;
   readonly placeholder: import("@angular/core").InputSignal<string>;
   readonly options: import("@angular/core").InputSignal<SelectOption<string | number>[]>;
   /** What the control value is: `'string'` (default, numeric option values become strings) or `'number'` (`number | null`). */
@@ -1095,7 +1153,7 @@ export declare class SelectComponent implements ControlValueAccessor, Validator,
   readonly error: import("@angular/core").InputSignal<string>;
   /** Reveal the built-in error messages now (e.g. after a failed Save click), without waiting for blur. */
   readonly showErrors: import("@angular/core").InputSignal<boolean>;
-  readonly size: import("@angular/core").InputSignal<"default" | "sm">;
+  readonly size: import("@angular/core").InputSignal<"sm" | "default">;
   readonly _disabledInput: import("@angular/core").InputSignal<boolean>;
   private readonly _cvaDisabled;
   protected readonly disabled: import("@angular/core").Signal<boolean>;
@@ -1124,6 +1182,13 @@ export declare class SelectComponent implements ControlValueAccessor, Validator,
   validate(control: AbstractControl): ValidationErrors | null;
   registerOnValidatorChange(fn: () => void): void;
   protected readonly _selectId: string;
+  private readonly _hostEl;
+  /**
+   * Library source 2026-11-04, not yet published. Puts the keyboard focus on the inner native `<select>` (`ref.focus()` via `viewChild`).
+   * Same options as the DOM method (`{ preventScroll: true }`). Safe at any time: before the view exists, or on a disabled field, it does
+   * nothing and never throws.
+   */
+  focus(options?: FocusOptions): void;
   private _onChange;
   private _warned;
   /** The comparison form of a key: in number mode a numeric text ('21.0', ' 21 ') becomes the canonical number text ('21'). */
@@ -1152,6 +1217,16 @@ export declare class SelectComponent implements ControlValueAccessor, Validator,
       "required": false;
       "isSignal": true;
     };
+    "labelHidden": {
+      "alias": "labelHidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "inputName": {
+      "alias": "inputName";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -1540,7 +1615,21 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
   readonly tabChange: import("@angular/core").OutputEmitterRef<string>;
   /** Emitted when the user applies a bulk action. The table has already filtered to eligible IDs. */
   readonly bulkAction: import("@angular/core").OutputEmitterRef<BulkActionEvent>;
+  /**
+   * Emitted when the user clicks a bulk action declared `{ field, action: true, opens: 'panel' }`. The table sends nothing: the host opens its
+   * own panel for `rows` and, when it has finished, calls `clearSelection()` and `refresh()` on the table.
+   */
+  readonly bulkPanelClick: import("@angular/core").OutputEmitterRef<BulkPanelEvent<T>>;
   /** Emitted after a built-in single-row delete completes successfully. */
+  /**
+   * Emitted after every rows request that completes (a request superseded by a newer one emits nothing; first load, page, sort, search, tab, filter, `refresh()` ...): `{ ok: true, total }` when the rows
+   * arrived (`total` = all matching rows), `{ ok: false, total }` when the request failed (the rows on screen are kept, `total` is the last known).
+   * Lets a host refresh something that must follow the table (e.g. a failure banner above it).
+   */
+  readonly loaded: import("@angular/core").OutputEmitterRef<{
+    ok: boolean;
+    total: number;
+  }>;
   readonly rowDeleted: import("@angular/core").OutputEmitterRef<T>;
   /**
    * Optional drag-and-drop ordering of the rows. Off by default; when `true` (and the user has full access) every row gets a grip
@@ -1763,6 +1852,8 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
   private _hostConfirm;
   /** Why a bulk action can't be used right now ('' = it can). Only Delete with `deletable` and a direct action with `eligible` can be blocked. */
   protected _bulkBlockedReason(def: BulkActionDef): string;
+  /** A panel action is not shown while the host says it is unavailable or no selected row is eligible. Everything else is always shown. */
+  protected _bulkHidden(def: BulkActionDef): boolean;
   /** The distinct reasons of the currently blocked bulk actions, shown as visible text next to the disabled buttons. */
   protected _bulkBlockedHints(): string[];
   /** Selected rows (loaded page) split by the delete option's `deletable` predicate; without it every selected row is deletable. */
@@ -1773,8 +1864,14 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
   protected readonly _runningAction: import("@angular/core").WritableSignal<string | null>;
   /** True while a direct action's confirm dialog is open (guards against a second click). */
   private _confirmingAction;
+  /** Panel action: no confirm and no request; hands the eligible rows to the host, which opens its own panel. */
+  private _openBulkPanel;
   /** Direct bulk action: confirm, then POST `<endpoint>/bulk/<key>` with `{ ids }` of the eligible rows. */
   private _runDirectAction;
+  /** Direct action that returns a file: POST `{ ids }` asking for a blob, save it as one download, toast, clear the selection. */
+  private _runDownloadAction;
+  /** The `{ message }` of a failed file request: with a blob response the error body arrives as a Blob, so it is read as text first. */
+  private _downloadErrorMessage;
   /** Called when the user clicks a bulk action button in the selection bar. */
   protected onBulkActionClick(def: BulkActionDef): void;
   /** True while the field-change confirmation dialog is open (guards against a second Apply click). */
@@ -2123,6 +2220,8 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
     "selectionChange": "selectionChange";
     "tabChange": "tabChange";
     "bulkAction": "bulkAction";
+    "bulkPanelClick": "bulkPanelClick";
+    "loaded": "loaded";
     "rowDeleted": "rowDeleted";
     "rowReorder": "rowReorder";
   }, never, never, true, never>;
@@ -2173,6 +2272,15 @@ export declare class SidePanelComponent implements OnDestroy {
   readonly closed: import("@angular/core").OutputEmitterRef<void>;
   readonly primaryClick: import("@angular/core").OutputEmitterRef<void>;
   protected readonly titleId: string;
+  /**
+   * (library source 2026-11-04, not yet published) True while the scrollable body (`.sp-body`) is taller than the space it has.
+   * Only then the body is a keyboard Tab stop (`tabindex="0"`, `role="group"`, named by the panel title via `aria-labelledby`)
+   * so keyboard users can scroll it with the arrow keys / Space / PageUp / PageDown. While the content fits, the body carries
+   * none of those attributes (unchanged markup). Kept current by a ResizeObserver + MutationObserver on the body.
+   */
+  readonly bodyScrollable: import("@angular/core").WritableSignal<boolean>;
+  private readonly _bodyRef;
+  private _bodyObservers;
   private readonly _el;
   private readonly _doc;
   private readonly _overlays;
@@ -2182,6 +2290,14 @@ export declare class SidePanelComponent implements OnDestroy {
   private _stopIframeKeys;
   private readonly _interaction;
   constructor();
+  /**
+   * Re-measures the body now (`scrollHeight` vs `clientHeight`, 1px tolerance for sub-pixel rounding) and updates
+   * `bodyScrollable`. Called by the observers; also usable by a host that changes the body content in a way no observer sees.
+   */
+  refreshScrollable(): void;
+  /** Starts observing the (new) body element, or stops observing when the body is gone (panel closed). */
+  private _watchBody;
+  private _stopWatchingBody;
   onKeydown(event: KeyboardEvent): void;
   /** A focus-guard sentinel received focus (Tab left the panel's tab order, e.g. out of an iframe): send it back inside. */
   protected onGuardFocus(which: 'start' | 'end', event?: FocusEvent): void;
@@ -2272,7 +2388,7 @@ export declare class ModalComponent implements OnInit, OnDestroy {
    */
   readonly describedBy: import("@angular/core").InputSignal<string | null>;
   readonly maxWidth: import("@angular/core").InputSignal<string>;
-  readonly bodyOverflow: import("@angular/core").InputSignal<"hidden" | "auto" | "visible">;
+  readonly bodyOverflow: import("@angular/core").InputSignal<"hidden" | "visible" | "auto">;
   /** `data-testid` of the dialog element itself (the host `<ui-modal>` is always in the page, the dialog only while open). None when empty. */
   readonly dialogTestId: import("@angular/core").InputSignal<string>;
   /** Hides the header X button (e.g. while a request is running). Escape and a backdrop click still close unless `closable` is false. */
@@ -2443,6 +2559,14 @@ export interface ToastOptions {
   key?: string;
   /** Called with the `id` of a button when it is used (before the toast closes). */
   onAction?: (actionId: string) => void;
+  /**
+   * (library source 2026-11-04, not yet published) Default `false` (unchanged). `true` = if a toast with the SAME message and the SAME type is on screen right
+   * now, show this one as a fresh toast of its own: the toast element is re-created (so a screen reader announces the text again and the
+   * entry animation replays), the dismiss timer restarts with this call's duration, and the title / buttons / countdown of this call replace
+   * the old ones. Nothing is queued. If the message on screen is different (or nothing is showing) `repeat` changes nothing. Without
+   * `repeat`, an identical message arriving while it is on screen only restarts the timer silently: it is not announced again.
+   */
+  repeat?: boolean;
 }
 /** What is known about the toast on screen beyond its message and type; `null` for a plain toast. */
 export interface ToastDetails {
@@ -2469,6 +2593,11 @@ export declare class ToastService implements OnDestroy {
   readonly persistentLiveRegion: import("@angular/core").WritableSignal<boolean>;
   /** The title, buttons, countdown flag, key and callback of the toast on screen; `null` for a plain toast or none. */
   readonly details: import("@angular/core").WritableSignal<ToastDetails | null>;
+  /**
+   * (library source 2026-11-04, not yet published) Counts the `repeat: true` re-presentations of an identical message. The outlet re-creates the toast
+   * element whenever it changes, which is what makes a screen reader announce the same text again. Starts at 0 and only grows.
+   */
+  readonly repeatTick: import("@angular/core").WritableSignal<number>;
   /** How many toasts are waiting behind the one on screen (queue mode). */
   readonly queuedCount: import("@angular/core").WritableSignal<number>;
   /** Default for `ToastOptions.queue`: new toasts wait for the one on screen instead of replacing it. Set with `provideForgerouteToast({ queue: true })` or `<ui-toast [queue]="true" />`. */
@@ -2560,6 +2689,8 @@ export declare class ToastComponent {
   readonly queueLabel: import("@angular/core").InputSignal<string>;
   /** A toast button was used (also after its own `onAction`). */
   readonly action: import("@angular/core").OutputEmitterRef<ToastActionEvent>;
+  /** One entry that changes with every `repeat: true` toast: the @for re-creates the toast element, so identical text is announced again. */
+  protected readonly repeatKeys: import("@angular/core").Signal<number[]>;
   protected readonly isRich: import("@angular/core").Signal<boolean>;
   protected readonly countdownPct: import("@angular/core").Signal<number>;
   protected readonly countdownText: import("@angular/core").Signal<string>;
@@ -2572,6 +2703,7 @@ export declare class ToastComponent {
    */
   private readonly _adoptedMessage;
   protected readonly adopted: import("@angular/core").Signal<boolean>;
+  private _lastRepeatTick;
   private _wasWaiting;
   private _hover;
   private _focus;
@@ -2830,7 +2962,7 @@ export declare class AudioPlayerComponent {
   /** Accessible name of the player. */
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
   /** How much to load before play: 'metadata' (default), 'auto' or 'none'. */
-  readonly preload: import("@angular/core").InputSignal<"none" | "auto" | "metadata">;
+  readonly preload: import("@angular/core").InputSignal<"none" | "metadata" | "auto">;
   /** Fires when the browser can't load or decode the source. */
   readonly playbackError: import("@angular/core").OutputEmitterRef<void>;
   protected readonly failed: import("@angular/core").WritableSignal<boolean>;
@@ -3084,7 +3216,7 @@ export declare class CheckboxComponent implements ControlValueAccessor, Validato
    * clicking it still toggles the box - e.g. a product name that is both the heading of its card and the label of its checkbox.
    * Default null: plain label text, exactly as before. Single mode only.
    */
-  readonly headingLevel: import("@angular/core").InputSignal<1 | 2 | 3 | 4 | 5 | 6 | null>;
+  readonly headingLevel: import("@angular/core").InputSignal<2 | 1 | 5 | 3 | 4 | 6 | null>;
   readonly indeterminate: import("@angular/core").InputSignal<boolean>;
   readonly checked: import("@angular/core").ModelSignal<boolean>;
   /**
@@ -3308,6 +3440,8 @@ export declare class ToggleComponent implements ControlValueAccessor {
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
   /** Id of another element that describes the switch (e.g. a description rendered elsewhere); announced after the hint. Absent when empty. */
   readonly ariaDescribedBy: import("@angular/core").InputSignal<string>;
+  /** `data-testid` put on the inner `<input role="switch">` (the host keeps its own attributes), so e2e can target the switch directly. Absent when empty. */
+  readonly inputTestId: import("@angular/core").InputSignal<string>;
   /** Whether the switch is on. Two-way: `[(checked)]`. */
   readonly checked: import("@angular/core").ModelSignal<boolean>;
   /** Public so a host template can bind `[disabled]` (a protected input fails strict template type-checking, TS2445). */
@@ -3350,6 +3484,11 @@ export declare class ToggleComponent implements ControlValueAccessor {
       "required": false;
       "isSignal": true;
     };
+    "inputTestId": {
+      "alias": "inputTestId";
+      "required": false;
+      "isSignal": true;
+    };
     "checked": {
       "alias": "checked";
       "required": false;
@@ -3482,7 +3621,7 @@ export declare class StepperComponent {
    * its circle, one continuous line behind the circles that fills as steps complete; a complete step shows a check, the current step an
    * accent ring with a dot, an upcoming step an empty circle (no numbers). Circles are 40px (32px with `size="sm"`).
    */
-  readonly labelPosition: import("@angular/core").InputSignal<"beside" | "below">;
+  readonly labelPosition: import("@angular/core").InputSignal<"below" | "beside">;
   /** Viewport width in px below which a horizontal stepper is drawn vertical (labels beside the circles), e.g. `640`. null (default) = never. */
   readonly stackBelow: import("@angular/core").InputSignal<number | null>;
   /** CSS length (e.g. `10.5rem`): horizontal only - the list gets `min-width: calc(<step count> * <value>)`. Empty (default) = no minimum. */
@@ -3799,6 +3938,11 @@ export interface RadioOption {
   disabled?: boolean;
   /** `data-testid` of this option's native radio input (e.g. for end-to-end tests); none when omitted. */
   testId?: string;
+  /**
+   * Library source 2026-11-04, not yet published. Icon drawn in front of the option's label: a `<ui-icon>` key (`cup`, `wrench`, ...) or a raw SVG
+   * path. Decorative (`aria-hidden`); none when omitted.
+   */
+  icon?: string;
 }
 /**
  * Group of native radio buttons inside a `<fieldset>` (+ `<legend>` = `label`), a ControlValueAccessor (string value, `''`
@@ -3995,7 +4139,7 @@ export declare class PhoneNumberPickerComponent {
   protected readonly modeCtl: FormControl<string>;
   protected readonly zipCtl: FormControl<string>;
   protected readonly areaCtl: FormControl<string>;
-  protected readonly step: import("@angular/core").WritableSignal<1 | 2 | 3>;
+  protected readonly step: import("@angular/core").WritableSignal<2 | 1 | 3>;
   protected readonly mode: import("@angular/core").WritableSignal<PhoneNumberSearchMode>;
   private readonly _zip;
   private readonly _area;
@@ -4111,7 +4255,7 @@ export declare class ButtonComponent {
    * `ghost-start`: a ghost button for list / section toggles - a full-width row with its content aligned to the start, transparent
    * background, hover tint and the normal focus ring. Pair it with `ariaExpanded` / `ariaPressed`; the label may contain a heading element.
    */
-  readonly variant: import("@angular/core").InputSignal<"primary" | "secondary" | "danger" | "warning" | "link" | "ghost" | "ghost-start" | "tab" | "icon" | "icon-danger">;
+  readonly variant: import("@angular/core").InputSignal<"link" | "primary" | "secondary" | "danger" | "warning" | "icon" | "ghost" | "ghost-start" | "tab" | "icon-danger">;
   /** Renders an anchor to this route instead of a button (use with `variant="link"` for an inline text link). `['/settings']` or `'/settings'`. While `disabled` or `loading` it renders a non-clickable `<span role="link" aria-disabled>` with no href (like `href`). */
   readonly routerLink: import("@angular/core").InputSignal<string | readonly unknown[] | null>;
   /** Query params of the `routerLink` (e.g. `{ section: 'deal-defaults' }`). */
@@ -4132,7 +4276,7 @@ export declare class ButtonComponent {
    */
   readonly href: import("@angular/core").InputSignal<string | null>;
   /** Where to open the `href` (`_blank` = a new tab). */
-  readonly target: import("@angular/core").InputSignal<"_self" | "_blank" | "_parent" | "_top" | null>;
+  readonly target: import("@angular/core").InputSignal<"_blank" | "_self" | "_parent" | "_top" | null>;
   /** `rel` of the `href` link. A `_blank` target always gets `noopener noreferrer` added. */
   readonly rel: import("@angular/core").InputSignal<string | null>;
   /** The href when it is allowed (http, https, mailto, tel, sms or a relative URL), else null. */
@@ -4166,6 +4310,14 @@ export declare class ButtonComponent {
   readonly ariaPressed: import("@angular/core").InputSignal<boolean | undefined>;
   /** Id of the element that describes this button (an error or hint rendered next to it), e.g. `<ui-error errorId="x">`. Absent when empty. */
   readonly ariaDescribedBy: import("@angular/core").InputSignal<string | undefined>;
+  private readonly _hostEl;
+  /**
+   * Library source 2026-11-04, not yet published. Puts the keyboard focus on the inner native control (the `<button>`, or the `<a>` of a
+   * `routerLink` / `href` button): `buttonRef.focus()` via `viewChild(ButtonComponent)`. Same options as the DOM method (`{ preventScroll: true }`).
+   * Safe at any time: before the view exists, or while the button is `disabled` / `loading` (a disabled `<button>` cannot take focus; the
+   * disabled-link `<span>` is not focusable), it does nothing and never throws.
+   */
+  focus(options?: FocusOptions): void;
   constructor();
   _footerLeft?: string;
   _footerRight?: string;
@@ -4376,11 +4528,26 @@ export declare class PillTabsComponent {
   /** 'vertical' stacks the tabs in a column (Up/Down arrows move between them, `aria-orientation="vertical"`). Default 'horizontal' = unchanged. */
   readonly orientation: import("@angular/core").InputSignal<"vertical" | "horizontal">;
   protected readonly vertical: () => boolean;
+  /**
+   * (library source 2026-11-04, not yet published) Associate the tabs with their panels: every tab gets
+   * `aria-controls="<name>-panel-<key>"`, the id a `uiTabPanel` directive gives its element (see `PillTabPanelDirective`).
+   * Default false = no `aria-controls` at all (unchanged markup). Turn it on only when every tab has a `uiTabPanel`
+   * element in the page, otherwise `aria-controls` would point at a missing id. The tab ids themselves are unchanged
+   * and always `<name>-<key>` (see `pillTabId`).
+   *
+   * Id collision: a tab whose KEY is `panel-x` has the id `<name>-panel-x`, which is also the panel id for key `x`. Avoid keys that start with
+   * `panel-` when this is on; in development mode a `console.warn` names such a key.
+   */
+  readonly controlsPanels: import("@angular/core").InputSignal<boolean>;
   readonly tabChange: import("@angular/core").OutputEmitterRef<string>;
   /** True while pills are hidden past the start / end edge of the scroll area (drives the fade hints). */
   protected readonly canScrollStart: import("@angular/core").WritableSignal<boolean>;
   protected readonly canScrollEnd: import("@angular/core").WritableSignal<boolean>;
   constructor();
+  /** Id of the tab button for [key] (`<name>-<key>`, the exported `pillTabId`). */
+  protected tabId(key: string): string;
+  /** Id of the panel [key] controls (`<name>-panel-<key>`, the exported `pillTabPanelId`). */
+  protected panelId(key: string): string;
   protected updateOverflow(): void;
   select(key: string): void;
   /** Roving tabindex — the selected tab (or the first enabled one when none is selected) is tabbable. */
@@ -4418,10 +4585,80 @@ export declare class PillTabsComponent {
       "required": false;
       "isSignal": true;
     };
+    "controlsPanels": {
+      "alias": "controlsPanels";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "tabChange": "tabChange";
   }, never, never, true, never>;
 }
+/** Id of the tab button `ui-pill-tabs` renders for [key] when its `name` input is [name] (always `<name>-<key>`). */
+export declare function pillTabId(name: string, key: string): string;
+/** Id a `uiTabPanel` element gets, and the id every tab's `aria-controls` points at when `controlsPanels` is on: `<name>-panel-<key>`. */
+export declare function pillTabPanelId(name: string, key: string): string;
+/**
+ * (library source 2026-11-04, not yet published) The panel that belongs to one `ui-pill-tabs` tab: a correct
+ * WAI-ARIA tablist / tabpanel association with the smallest possible markup.
+ *
+ * ```html
+ * <ui-pill-tabs name="billing" [tabs]="tabs" [activeKey]="tab()" [controlsPanels]="true" (tabChange)="tab.set($event)" />
+ * <section uiTabPanel="invoices" tabsName="billing" [activeKey]="tab()"> ... </section>
+ * <section uiTabPanel="payments" tabsName="billing" [activeKey]="tab()"> ... </section>
+ * ```
+ *
+ * The host element gets `role="tabpanel"`, `id="<tabsName>-panel-<key>"` and `aria-labelledby="<tabsName>-<key>"` (the tab button).
+ * - `uiTabPanel`  the key of the tab this panel belongs to (required, the same `key` as in the tabs list).
+ * - `tabsName`    the `name` input of the `ui-pill-tabs` (required; give the tabs a fixed `name` so the ids are predictable).
+ * - `activeKey`   the tabs' active key. When given (not null), the panel gets the `hidden` attribute while another tab is active
+ *                 (the panels stay in the DOM, so their state survives a tab change). Leave it unset when the page renders only the
+ *                 active panel itself (`@if`), then no `hidden` attribute is ever set.
+ * - `tabbable`    default false. true adds `tabindex="0"` so a panel without any focusable content can be reached by keyboard
+ *                 (WAI-ARIA tabs pattern).
+ *
+ * Id collision: ids are plain strings, so a tab whose KEY is `panel-x` has the tab id `<name>-panel-x`, which is the same string as the panel id of the
+ * key `x`. Do not use keys that start with `panel-` together with `controlsPanels` (`ui-pill-tabs` logs a `console.warn` for such a key in development mode).
+ *
+ * Note: the `hidden` attribute loses against an author rule such as `display: flex` on the same element; put such layout on an
+ * inner element, or style `[hidden] { display: none }`.
+ */
+export declare class PillTabPanelDirective {
+  /** Key of the tab this panel belongs to. */
+  readonly key: import("@angular/core").InputSignal<string>;
+  /** `name` of the `ui-pill-tabs` this panel belongs to. */
+  readonly tabsName: import("@angular/core").InputSignal<string>;
+  /** Active key of the tabs; the panel is `hidden` while it is another key. null (default) = never hidden by this directive. */
+  readonly activeKey: import("@angular/core").InputSignal<string | null>;
+  /** Makes the panel itself a Tab stop (for panels with no focusable content). Default false. */
+  readonly tabbable: import("@angular/core").InputSignal<boolean>;
+  protected panelId(): string;
+  protected tabId(): string;
+  protected isHidden(): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PillTabPanelDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<PillTabPanelDirective, "[uiTabPanel]", never, {
+    "key": {
+      "alias": "uiTabPanel";
+      "required": true;
+      "isSignal": true;
+    };
+    "tabsName": {
+      "alias": "tabsName";
+      "required": true;
+      "isSignal": true;
+    };
+    "activeKey": {
+      "alias": "activeKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "tabbable": {
+      "alias": "tabbable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 export interface ContactLookup {
   id: string;
   name: string;
@@ -4663,7 +4900,7 @@ export declare class ImportSourceGridComponent {
   /** The `value` of the picked source (highlighted). `tile` only: the `card` appearance does not keep a selection. */
   readonly selected: import("@angular/core").InputSignal<string>;
   /** `tile`: the compact buttons of the import window. `card`: one `ui-detail-card` per source with its own select button (used on a page). */
-  readonly appearance: import("@angular/core").InputSignal<"card" | "tile">;
+  readonly appearance: import("@angular/core").InputSignal<"tile" | "card">;
   /** `card`: disables every card's button (for example while the page is saving). */
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   /** `card`: the text of each card's button. */
@@ -4860,7 +5097,7 @@ export declare class BankAccountFormComponent implements UiFieldValidity {
   protected readonly accountError: import("@angular/core").Signal<"" | "Account number must be at least 4 digits.">;
   protected readonly confirmError: import("@angular/core").Signal<"" | "Account numbers do not match.">;
   /** First reason the form cannot be submitted ('' when it can). */
-  readonly errorMessage: import("@angular/core").Signal<"" | "Account holder name is required." | "Routing number is required." | "Routing number must be 9 digits." | "Account number is required." | "Account number must be at least 4 digits." | "Confirm account number is required." | "Account numbers do not match." | "Select a valid account type." | "Select a valid holder type." | "You must authorize ACH debits to continue.">;
+  readonly errorMessage: import("@angular/core").Signal<"" | "Routing number must be 9 digits." | "Account number must be at least 4 digits." | "Account numbers do not match." | "Account holder name is required." | "Routing number is required." | "Account number is required." | "Confirm account number is required." | "Select a valid account type." | "Select a valid holder type." | "You must authorize ACH debits to continue.">;
   /** True while the form cannot be submitted (`UiFieldValidity`). */
   readonly invalid: import("@angular/core").Signal<boolean>;
   /** True when the form can be submitted (ignores `disabled` / `busy`). */
@@ -4929,7 +5166,11 @@ export interface ActiveConfirm {
   /** Optional bullet list rendered under the message (plain text). */
   details: string[];
 }
-export declare class ConfirmService {
+export declare class ConfirmService implements OnDestroy {
+  private readonly _appRef;
+  private readonly _envInjector;
+  private readonly _doc;
+  private readonly _browser;
   private _open;
   private _active;
   private _resolve;
@@ -4943,8 +5184,24 @@ export declare class ConfirmService {
    */
   private readonly _outlets;
   readonly primaryOutlet: import("@angular/core").Signal<object>;
+  /**
+   * The outlet this service created itself because `confirm()` was called while no `<ui-confirm-outlet>` existed (a page without a
+   * `ui-data-table` and without a hand-placed outlet). Null while a template-placed outlet exists, before the first such confirm, and
+   * on the server. Library source 2026-11-04, not yet published.
+   */
+  private _auto;
+  /** True when a template-placed outlet appeared while the auto outlet's dialog was open: the auto outlet is removed once that dialog closes. */
+  private _retireAutoOnDismiss;
   registerOutlet(outlet: object): void;
   unregisterOutlet(outlet: object): void;
+  ngOnDestroy(): void;
+  /**
+   * Makes sure some outlet exists to render the dialog. Template-placed outlets (data-table, app-shell, a hand-placed
+   * `<ui-confirm-outlet />`) are used as they are; only when there is none is one outlet created and attached to `document.body`
+   * (reused for later confirms, removed when the service is destroyed or a template-placed outlet appears). Does nothing without a DOM (SSR).
+   */
+  private _ensureOutlet;
+  private _destroyAuto;
   confirm(config: {
     title: string;
     message: string;
@@ -4999,12 +5256,19 @@ export declare class EmptyStateComponent {
   }, {}, never, ["*"], true, never>;
 }
 export declare class ErrorStateComponent {
+  /** Optional bold heading line above the message (e.g. "Unable to load application"). Empty = no heading. */
+  readonly title: import("@angular/core").InputSignal<string>;
   readonly message: import("@angular/core").InputSignal<string>;
   readonly retryLabel: import("@angular/core").InputSignal<string>;
   readonly retrying: import("@angular/core").InputSignal<boolean>;
   readonly retry: import("@angular/core").OutputEmitterRef<void>;
   static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<ErrorStateComponent, "ui-error-state", never, {
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
     "message": {
       "alias": "message";
       "required": false;
@@ -5082,6 +5346,8 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
    * and `inputTestId="email-input"`. Omitted = no attribute.
    */
   readonly inputTestId: import("@angular/core").InputSignal<string>;
+  /** Native `name` attribute placed on the inner `<input>` (e2e `[name=x]` selectors, browser autofill). None when empty. */
+  readonly inputName: import("@angular/core").InputSignal<string>;
   readonly placeholder: import("@angular/core").InputSignal<string>;
   /**
    * An optional leading mark shown inside the field, left of the text (e.g. `prefix="$"` for a dollar amount). Hidden unless set; it is
@@ -5089,6 +5355,12 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
    * Meant for a short mark of 1-3 characters.
    */
   readonly prefix: import("@angular/core").InputSignal<string>;
+  /**
+   * Library source 2026-11-04, not yet published. An optional icon at the left inside the field: a `<ui-icon>` key, e.g. `leadingIcon="search"` for a search field.
+   * Decorative (`aria-hidden`, no pointer events, not part of the value), so give the field a `label` or `ariaLabel`. The input's left padding grows to
+   * make room (36px; with a `prefix` the mark moves right of the icon). An unknown key or empty (default) draws nothing and changes nothing.
+   */
+  readonly leadingIcon: import("@angular/core").InputSignal<string>;
   /**
    * `type="password"` only: puts an eye button inside the field, at its right end, that shows / hides the typed text (the eye with a slash
    * means "hidden again"). Per field, starts hidden; the button is a toggle (`aria-pressed`) named "Show password". Ignored for other types.
@@ -5101,7 +5373,7 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
   readonly passwordRequirements: import("@angular/core").InputSignal<boolean>;
   /** Rules for `passwordRequirements`; default = the library's five rules (8+ characters, upper, lower, digit, special). */
   readonly passwordRules: import("@angular/core").InputSignal<readonly PasswordRule[] | undefined>;
-  readonly type: import("@angular/core").InputSignal<"number" | "text" | "email" | "tel" | "password" | "url">;
+  readonly type: import("@angular/core").InputSignal<"number" | "text" | "email" | "password" | "tel" | "url">;
   readonly maxlength: import("@angular/core").InputSignal<number | undefined>;
   readonly required: import("@angular/core").InputSignal<boolean>;
   readonly autocomplete: import("@angular/core").InputSignal<string>;
@@ -5110,7 +5382,7 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
    * `search`, `text`, `none`). Empty (default) = the browser's default for the field, except `type="tel"`, which keeps `tel`.
    * It only picks the keyboard; it does not restrict what can be typed or pasted.
    */
-  readonly inputmode: import("@angular/core").InputSignal<"" | "none" | "text" | "search" | "email" | "tel" | "url" | "decimal" | "numeric">;
+  readonly inputmode: import("@angular/core").InputSignal<"" | "none" | "text" | "email" | "search" | "tel" | "url" | "decimal" | "numeric">;
   readonly readonly: import("@angular/core").InputSignal<boolean>;
   readonly hint: import("@angular/core").InputSignal<string>;
   /** Id(s) of an external element that also describes this control (e.g. one shared error text for a group of fields). Space separated; MERGED after the control's own hint / error id in `aria-describedby`, never replacing it. Empty = unchanged. */
@@ -5168,15 +5440,21 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
   protected readonly disabled: import("@angular/core").Signal<boolean>;
   protected readonly _value: import("@angular/core").WritableSignal<string>;
   private readonly _reveal;
-  /** Left padding that makes room for the prefix (its width in `ch` plus the field's own 12px and a 6px gap); none without a prefix. */
+  /** Path of the leading icon, or null when `leadingIcon` is empty or not a known icon key. */
+  protected readonly _leadingD: import("@angular/core").Signal<string | null>;
+  /**
+   * Left padding that makes room for the prefix (its width in `ch` plus the field's own 12px and a 6px gap) and/or the leading icon (a 16px icon
+   * plus an 8px gap, so 36px from the edge); none without either.
+   */
   protected readonly _prefixPadding: import("@angular/core").Signal<string | null>;
+  private readonly _fieldEl;
   /** True when the control value is a number: `valueType="number"` on a `type="number"` field. */
   private readonly _numeric;
   /** The native `step` attribute: only for `type="number"` and only for a finite number above 0; otherwise none (the browser's step of 1). */
   protected readonly _stepAttr: import("@angular/core").Signal<string | null>;
   protected readonly _revealable: import("@angular/core").Signal<boolean>;
   protected readonly _shown: import("@angular/core").WritableSignal<boolean>;
-  protected readonly _inputType: import("@angular/core").Signal<"number" | "text" | "email" | "tel" | "password" | "url">;
+  protected readonly _inputType: import("@angular/core").Signal<"number" | "text" | "email" | "password" | "tel" | "url">;
   protected readonly _eyePath: string;
   protected readonly _eyeOffPath: string;
   protected readonly _showRequirements: import("@angular/core").Signal<boolean>;
@@ -5195,6 +5473,12 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
   protected readonly _activeError: import("@angular/core").Signal<string>;
   protected readonly _inputId: string;
   private static readonly _EMAIL_RE;
+  /**
+   * Library source 2026-11-04, not yet published. Puts the keyboard focus on the inner `<input>` (e.g. after a panel opens or a search is cleared):
+   * `fieldRef.focus()` via `viewChild(TextInputComponent)`. Same options as the DOM method (`{ preventScroll: true }`). Safe at any time: before the
+   * view exists, or on a disabled field, it does nothing and never throws.
+   */
+  focus(options?: FocusOptions): void;
   private _onChange;
   private _onTouched;
   private _onValidatorChange;
@@ -5240,6 +5524,11 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
       "required": false;
       "isSignal": true;
     };
+    "inputName": {
+      "alias": "inputName";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -5250,6 +5539,11 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
       "required": false;
       "isSignal": true;
     };
+    "leadingIcon": {
+      "alias": "leadingIcon";
+      "required": false;
+      "isSignal": true;
+    };
     "revealable": {
       "alias": "revealable";
       "required": false;
@@ -5507,6 +5801,13 @@ export declare class TextareaInputComponent implements ControlValueAccessor, Val
   validate(control: AbstractControl): ValidationErrors | null;
   registerOnValidatorChange(fn: () => void): void;
   protected readonly _inputId: string;
+  private readonly _hostEl;
+  /**
+   * Library source 2026-11-04, not yet published. Puts the keyboard focus on the inner native `<textarea>` (`ref.focus()` via `viewChild`).
+   * Same options as the DOM method (`{ preventScroll: true }`). Safe at any time: before the view exists, or on a disabled field, it does
+   * nothing and never throws.
+   */
+  focus(options?: FocusOptions): void;
   private _onChange;
   private _onTouched;
   writeValue(val: string | null): void;
@@ -6979,7 +7280,7 @@ export declare class FormSectionComponent {
   }, {}, never, ["*"], true, never>;
 }
 export declare class FormRowComponent {
-  readonly cols: import("@angular/core").InputSignal<1 | 2 | 3 | 4>;
+  readonly cols: import("@angular/core").InputSignal<2 | 1 | 3 | 4>;
   static ɵfac: i0.ɵɵFactoryDeclaration<FormRowComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<FormRowComponent, "ui-form-row", never, {
     "cols": {
@@ -6996,7 +7297,7 @@ export declare class FormRowComponent {
  * child simply takes the full width. Keep a numeric span within the row's `cols` (use `all` for the whole row).
  */
 export declare class FormColSpanDirective {
-  readonly uiColSpan: import("@angular/core").InputSignal<"" | "2" | "3" | 2 | 3 | "all">;
+  readonly uiColSpan: import("@angular/core").InputSignal<"" | 2 | 3 | "2" | "3" | "all">;
   protected readonly _class: import("@angular/core").Signal<string>;
   static ɵfac: i0.ɵɵFactoryDeclaration<FormColSpanDirective, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<FormColSpanDirective, "[uiColSpan]", never, {
@@ -7035,6 +7336,16 @@ export declare class FormColSpanDirective {
  *                 badge="Archived" badgeVariant="gray" [alwaysShowBadge]="true">
  *     <ui-button list-item-action variant="icon" ariaLabel="Remove" (click)="remove(d)">…</ui-button>
  *   </ui-list-item>
+ *
+ * Library source 2026-11-04, not yet published: `[disabled]` (aria-disabled, not focusable, never emits `select`, non-colour cue), `[busy]`
+ * (aria-busy, spinner, presses ignored) and a leading image slot, `<img list-item-image>` / `<ui-image list-item-image>`, rendered in front of
+ * the text and instead of the icon tile (clicks on it select a plain row; on a radio / checkbox row they do not, because the image sits outside
+ * the label). An interactive image (`<ui-image list-item-image [interactive]="true" (activate)=...>`) inside a plain pressable row: a click emits the
+ * image's `activate` AND selects the row (the click bubbles); Enter / Space on the image emit `activate` only (the row's key handler ignores keys
+ * whose target is not the row itself). Row-end actions stay in `list-item-action`.
+ *   <ui-list-item [title]="p.name" [details]="[p.price]" [disabled]="p.soldOut" [busy]="adding() === p.id" (select)="add(p)">
+ *     <ui-image list-item-image [src]="p.photo" [alt]="p.name" width="48px" height="48px" fit="cover" radius="md" />
+ *   </ui-list-item>
  */
 /** One secondary line under the title: plain text, or text with a small icon and a tone (`danger` red, `warning` amber). */
 export type ListItemDetail = string | {
@@ -7044,9 +7355,10 @@ export type ListItemDetail = string | {
 };
 /** Colour of the optional leading icon tile. */
 export type ListItemIconColor = 'slate' | 'amber' | 'red' | 'blue' | 'green' | 'purple' | 'teal' | 'orange';
-export declare class ListItemComponent {
+export declare class ListItemComponent implements AfterContentChecked {
+  private readonly host;
   /** Show a radio button, checkbox, or nothing on the left. */
-  readonly leading: import("@angular/core").InputSignal<"none" | "checkbox" | "radio">;
+  readonly leading: import("@angular/core").InputSignal<"none" | "radio" | "checkbox">;
   /** `name` attribute for the radio/checkbox (groups radios together). */
   readonly inputName: import("@angular/core").InputSignal<string>;
   /** `id` attribute for the radio/checkbox (links the label). */
@@ -7071,7 +7383,24 @@ export declare class ListItemComponent {
    * Rows with `[interactive]="false"` always wrap (new in 2026-10-19, nothing to preserve).
    */
   readonly wrapText: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Library source 2026-11-04, not yet published. `true` = the row cannot be used right now: the native radio / checkbox is `disabled` (that carries
+   * the state for assistive tech), a plain pressable row (`role="button"`) gets `aria-disabled="true"` and loses its `tabindex` (not a tab stop). A row
+   * without a role (radio / checkbox row wrapper, non-interactive row) gets NO `aria-disabled` (it is not valid on a role-less div); it only
+   * gets the classes. Clicks, Enter and Space never emit `select`, and the row looks disabled without relying on colour alone (dimmed, muted
+   * surface, `not-allowed` cursor, a dashed outline on a bordered card). Projected row-end actions (`list-item-action`) are NOT disabled by this
+   * input; disable them yourself. Default `false` = unchanged.
+   */
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Library source 2026-11-04, not yet published. `true` = the row is working on a request: `aria-busy="true"`, a small spinner (decorative)
+   * at the row end, and presses (click, Enter, Space, radio / checkbox change) are ignored: `select` never emits and a radio / checkbox keeps
+   * its state (the click is cancelled, so a sibling radio of the same `name` stays checked too; arrow keys on a busy radio are blocked).
+   * The row stays focusable. Default `false` = unchanged.
+   */
+  readonly busy: import("@angular/core").InputSignal<boolean>;
   get _borderedClass(): boolean;
+  get _disabledClass(): boolean;
   /** Primary label. */
   readonly title: import("@angular/core").InputSignal<string>;
   /** Badge shown next to the title — only visible when the item is checked, unless `alwaysShowBadge` is set. */
@@ -7092,6 +7421,21 @@ export declare class ListItemComponent {
   readonly select: import("@angular/core").OutputEmitterRef<void>;
   /** A plain interactive row (no radio/checkbox) is itself clickable: click, Enter or Space emit `select`. */
   protected readonly pressable: () => boolean;
+  /**
+   * True while the leading image slot (`<img list-item-image>` / any element with the `list-item-image` attribute) holds content.
+   * The slot is projected, so this is read from the DOM after every content check; the icon tile is not rendered while it is true.
+   */
+  protected readonly hasImage: import("@angular/core").WritableSignal<boolean>;
+  ngAfterContentChecked(): void;
+  /**
+   * Radio / checkbox click while busy or disabled: cancelled, so the browser restores the checkedness of the clicked input AND of the other radios of
+   * the same `name` group (clicking or arrowing onto this radio would otherwise uncheck the sibling that the model still holds as checked).
+   */
+  protected onInputClick(e: Event): void;
+  /** Arrow keys on a busy / disabled radio would move the selection to a sibling of the group: blocked. (Arriving at it from a sibling is stopped by `onInputClick`.) */
+  protected onInputKey(e: KeyboardEvent): void;
+  /** Radio / checkbox change: never while disabled (the input is disabled anyway); ignored while busy. Safety net after `onInputClick`: the input is put back to `checked`. */
+  protected onInputChange(e: Event): void;
   protected onRowClick(e: Event): void;
   protected onRowKey(e: Event): void;
   protected readonly visibleDetails: () => {
@@ -7146,6 +7490,16 @@ export declare class ListItemComponent {
       "required": false;
       "isSignal": true;
     };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "busy": {
+      "alias": "busy";
+      "required": false;
+      "isSignal": true;
+    };
     "title": {
       "alias": "title";
       "required": false;
@@ -7178,7 +7532,7 @@ export declare class ListItemComponent {
     };
   }, {
     "select": "select";
-  }, never, ["[list-item-action], [li-action]"], true, never>;
+  }, never, ["[list-item-image]", "[list-item-action], [li-action]"], true, never>;
 }
 /** Colour of the priority dot (`high` red, `medium` amber, `low` grey, `blue`, `green`); `none` = no dot. */
 export type CardListIndicator = 'high' | 'medium' | 'low' | 'blue' | 'green' | 'none';
@@ -7573,6 +7927,12 @@ export declare class ListComponent<T = unknown> {
   readonly items: import("@angular/core").InputSignal<readonly T[]>;
   /** `false` (default) renders a `<ul>`; `true` renders an `<ol>` with native numbering (no numbers in the grid layout). */
   readonly ordered: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Library source 2026-11-04, not yet published. `true` = the `<ul>` shows a visible bullet (disc) before every row, for plain text lines such as a
+   * "what will happen" list: `<ui-list [items]="lines" [bulleted]="true" ariaLabel="What will happen" />` (string items render as their text, no template needed).
+   * Still a real `<ul>` with `<li>` rows. Ignored with `[ordered]="true"` (which already has numbers) and in the grid layout. Default `false` = no markers, as before.
+   */
+  readonly bulleted: import("@angular/core").InputSignal<boolean>;
   /** 'list' = one column; 'grid' = wrapping columns of at least `gridMin` px (still a real `<ul>`). */
   readonly layout: import("@angular/core").InputSignal<"list" | "grid">;
   /** Minimum column width in px of the grid layout. */
@@ -7679,6 +8039,11 @@ export declare class ListComponent<T = unknown> {
       "required": false;
       "isSignal": true;
     };
+    "bulleted": {
+      "alias": "bulleted";
+      "required": false;
+      "isSignal": true;
+    };
     "layout": {
       "alias": "layout";
       "required": false;
@@ -8130,9 +8495,9 @@ export declare class ChipGroupComponent {
   readonly spaceAbove: import("@angular/core").InputSignal<"none" | "sm" | "md">;
   /** Space below the chip group. */
   readonly spaceBelow: import("@angular/core").InputSignal<"none" | "sm" | "md">;
-  protected readonly _gap: import("@angular/core").Signal<"6px" | "12px" | "8px">;
-  protected readonly _spaceAbove: import("@angular/core").Signal<"0" | "6px" | "12px">;
-  protected readonly _spaceBelow: import("@angular/core").Signal<"0" | "6px" | "12px">;
+  protected readonly _gap: import("@angular/core").Signal<"8px" | "12px" | "6px">;
+  protected readonly _spaceAbove: import("@angular/core").Signal<"0" | "12px" | "6px">;
+  protected readonly _spaceBelow: import("@angular/core").Signal<"0" | "12px" | "6px">;
   static ɵfac: i0.ɵɵFactoryDeclaration<ChipGroupComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<ChipGroupComponent, "ui-chip-group", never, {
     "gap": {
@@ -8508,10 +8873,15 @@ export declare class AlertComponent {
     "dismissed": "dismissed";
   }, never, ["*"], true, never>;
 }
+/**
+ * Every key `<ui-icon>` draws by itself (the data-table action keys such as `view` / `edit` / `call` are accepted too, see `builtInActionIcon`).
+ * Each resolves with `iconPath(key)`. Includes `search`, `cup` (food / drink) and `wrench` (rental / tools), library source 2026-11-04, not yet published.
+ */
+export declare const ICON_NAMES: readonly string[];
 /** The SVG path (24×24 stroke icon) for an icon key, or undefined when the key is unknown. */
 export declare function iconPath(name: string): string | undefined;
 /** Keys with an icon of their own (the data-table action keys are accepted too — see `builtInActionIcon`). */
-export type IconName = 'add' | 'close' | 'check' | 'upload' | 'image' | 'chevron-up' | 'chevron-down' | 'arrow-left' | 'bell' | 'print' | 'lock' | 'shield' | 'arrow-up' | 'arrow-down' | 'arrow-right' | 'document' | 'grip' | 'card' | 'bank' | 'view' | 'view-off' | 'edit' | 'delete' | 'download' | 'duplicate' | 'archive' | 'restore' | 'share' | 'email' | 'message' | 'call' | 'refund' | 'chevron-right' | 'link' | 'save' | 'chart' | 'clipboard' | 'unlink' | 'send' | 'refresh';
+export type IconName = 'add' | 'close' | 'check' | 'upload' | 'image' | 'chevron-up' | 'chevron-down' | 'arrow-left' | 'bell' | 'print' | 'lock' | 'shield' | 'arrow-up' | 'arrow-down' | 'arrow-right' | 'document' | 'grip' | 'card' | 'bank' | 'view' | 'view-off' | 'edit' | 'delete' | 'download' | 'duplicate' | 'archive' | 'restore' | 'share' | 'email' | 'message' | 'call' | 'refund' | 'chevron-right' | 'link' | 'save' | 'chart' | 'clipboard' | 'unlink' | 'send' | 'refresh' | 'search' | 'cup' | 'wrench';
 /**
  * A clickable icon. The host passes a key (`name="delete"`) and the library draws that icon; clicking it emits
  * `iconClick`, and the host does the actual work (delete the row, open a panel, …).
@@ -8731,6 +9101,341 @@ export declare class HintComponent {
   static ɵfac: i0.ɵɵFactoryDeclaration<HintComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<HintComponent, "ui-hint", never, {}, {}, never, ["*"], true, never>;
 }
+/**
+ * The value of `ui-address-input`: five plain strings (never null). `apt` is the second line (apartment / suite / unit).
+ *
+ * Note: the library already exports `formatAddress(parts, options)` / `AddressParts` (utils/format) for display of an address with
+ * city / state / zip parts. The helpers below work on this value model and are therefore named `...AddressValue`.
+ */
+export interface AddressValue {
+  street: string;
+  apt: string;
+  city: string;
+  state: string;
+  zip: string;
+}
+/** The 50 US states + DC as select options: value = 2-letter code, label = the code (compact, fits the narrow State column), description = the state name (read by screen readers, shown under the select). */
+export declare const US_STATE_OPTIONS: readonly SelectOption[];
+/** A fresh blank address. */
+export declare function emptyAddress(): AddressValue;
+/** Coerces anything (null, a partial object, non-string members) to a complete `AddressValue` of strings. */
+export declare function normalizeAddress(v: Partial<Record<keyof AddressValue, unknown>> | null | undefined): AddressValue;
+/** True when every part is empty or whitespace (null / undefined count as empty). */
+export declare function isEmptyAddress(a: Partial<Record<keyof AddressValue, unknown>> | null | undefined): boolean;
+/** The default ZIP rule of the component: US 5 digits or 5+4. */
+export declare const US_ZIP_PATTERN: RegExp;
+/**
+ * Multi-line text, the storage form used by apps: street, apt, then "City, ST 12345", joined with "\n". Every part is trimmed and empty
+ * parts are left out, so `parseAddressValue(formatAddressValue(x))` is stable.
+ * `{street:'1 Main', apt:'Apt 4', city:'Austin', state:'TX', zip:'78701'}` -> `"1 Main\nApt 4\nAustin, TX 78701"`.
+ */
+export declare function formatAddressValue(a: AddressValue | null | undefined): string;
+/**
+ * The same address on ONE line for tables, labels and maps: "1 Main, Apt 4, Austin, TX 78701". `{ comma: false }` drops the comma between
+ * city and state ("1 Main, Apt 4, Austin TX 78701", the older mfh resident style). Empty parts are left out.
+ */
+export declare function formatAddressValueOneLine(a: AddressValue | null | undefined, options?: {
+  comma?: boolean;
+}): string;
+/**
+ * Reads the multi-line text form back into an address (the inverse of `formatAddressValue`; never throws).
+ *  - null / undefined / blank -> empty address.
+ *  - 1 line: the street only (`parseAddressOneLine` reads the one-line form).
+ *  - 2 lines: street + city line. 3 lines: street + apt + city line.
+ *  - 4+ lines: first = street, last = city line, everything in between = apt (joined with ", ").
+ *  - The city line may be "City, ST 12345", "City ST 12345", "City, ST 12345-6789", "city, st 12345" (any case with a comma), "City, ST",
+ *    "TX 78701" (city blank), with a trailing comma / period / semicolon tolerated. The state is two letters (capitals unless a comma
+ *    separates it), the ZIP 5 digits or 5+4. Anything else (a city only, a full state name, a 4-digit or foreign postcode, a unit line
+ *    without a city line) lands WHOLE in `city` - nothing is dropped.
+ *  - Lines are trimmed, blank lines dropped, \r\n accepted.
+ */
+export declare function parseAddressValue(raw: string | null | undefined): AddressValue;
+/**
+ * Reads the ONE-LINE form that `formatAddressValueOneLine` writes ("street[, apt], city, ST 12345", or "..., city ST 12345" without the
+ * comma). Segments are split at commas: the last one carries "ST 12345" (and the city when there is no comma before the state), the city
+ * is the segment before it, the first remaining segment is the street and the rest the apt. A street that itself contains a comma
+ * ("Bldg 2, 100 Main St") therefore splits into street + apt. Text that does not end in "ST 12345" becomes the street whole.
+ */
+export declare function parseAddressOneLine(raw: string | null | undefined): AddressValue;
+/** 5 digits or 5+4 ("12345", "12345-6789"); surrounding spaces are NOT accepted (trim first). */
+export declare function isValidZip(zip: string): boolean;
+type AddressField = keyof AddressValue;
+/**
+ * Address entry (ControlValueAccessor): street, unit, city, state (select) and ZIP, built only from library inputs.
+ *
+ * Value: `AddressValue` ({ street, apt, city, state, zip }, all strings). Works with `[(ngModel)]`, `[formControl]`, or a signal via
+ * `[value]` / `(valueChange)`. A written `null` / `undefined` clears the form; a written string is read with `parseAddressValue`.
+ * Writing a value never emits; only user edits emit (the whole new `AddressValue`).
+ *
+ * Built-in validation (also reported on the form control as a `Validator`; `invalid` / `errorMessage` signals, `invalidChange` output,
+ * provides `UiFieldValidity`): `required` -> street, city, state and ZIP are required ("<Field label> is required."); ZIP must be
+ * 5 digits or 5+4 ("Enter a valid ZIP code."); state must be one of the options ("Select a valid option."); maxlengths
+ * ("Too long (max N characters)."); `requireComplete` -> once ANY of street / city / state / ZIP is filled the others are required too
+ * (for an optional address that must not be half-filled). The unit is never required. Messages show per field after that field was left,
+ * or all at once while `showErrors` is true; the host `error` is shown under the group and always counts as invalid.
+ *
+ * Layout: street + unit, then city + state + ZIP in `ui-form-row`s (they collapse to one column on phones).
+ */
+export declare class AddressInputComponent implements ControlValueAccessor, Validator, UiFieldValidity {
+  /** Group label (the visible legend and the group's accessible name). Empty -> no legend, the group is named "Address". */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Street, city, state and ZIP are required (never the unit). Shows `*` on the legend and on those fields. */
+  readonly required: import("@angular/core").InputSignal<boolean>;
+  /** Optional address that must not be half-filled: when any of street / city / state / ZIP has text, the other three are required. */
+  readonly requireComplete: import("@angular/core").InputSignal<boolean>;
+  readonly streetLabel: import("@angular/core").InputSignal<string>;
+  readonly unitLabel: import("@angular/core").InputSignal<string>;
+  readonly cityLabel: import("@angular/core").InputSignal<string>;
+  readonly stateLabel: import("@angular/core").InputSignal<string>;
+  readonly zipLabel: import("@angular/core").InputSignal<string>;
+  readonly streetPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly unitPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly cityPlaceholder: import("@angular/core").InputSignal<string>;
+  readonly zipPlaceholder: import("@angular/core").InputSignal<string>;
+  /** Text of the empty State option (the one that clears the state). */
+  readonly statePlaceholder: import("@angular/core").InputSignal<string>;
+  /** Show the Apt / Suite field. Hidden -> the value's `apt` is kept as written and never edited. */
+  readonly showUnit: import("@angular/core").InputSignal<boolean>;
+  /** State choices (value = what is stored). Default: the 50 US states + DC by code. An empty "no state" option is added in front when missing. */
+  readonly states: import("@angular/core").InputSignal<readonly SelectOption<string>[]>;
+  readonly streetMaxlength: import("@angular/core").InputSignal<number>;
+  readonly unitMaxlength: import("@angular/core").InputSignal<number>;
+  readonly cityMaxlength: import("@angular/core").InputSignal<number>;
+  readonly zipMaxlength: import("@angular/core").InputSignal<number>;
+  /** Native select cannot be read-only: while `readonly`, the State select is disabled and the text fields are read-only. */
+  readonly readonly: import("@angular/core").InputSignal<boolean>;
+  /** Reveal every built-in message now (e.g. after a failed Save click). Switching back to false forgets which fields were left. */
+  readonly showErrors: import("@angular/core").InputSignal<boolean>;
+  readonly hint: import("@angular/core").InputSignal<string>;
+  /** Host error for the whole address; shown under the group (replaces the hint), always makes the field invalid. */
+  readonly error: import("@angular/core").InputSignal<string>;
+  /** Prefix of the per-field test ids and native names: `<prefix>street`, `<prefix>apt`, `<prefix>city`, `<prefix>state`, `<prefix>zip` (and `<prefix>group`). */
+  readonly idPrefix: import("@angular/core").InputSignal<string>;
+  /** Alias of `idPrefix` (the name the old app-level address input used). When set (even to ''), it wins over `idPrefix`. */
+  readonly prefix: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * What the form control (ngModel / FormControl) receives. 'auto' (default): the type last written to it - a string model gets the multi-line
+   * string (`formatAddressValue`), an object / null / never-written model gets the `AddressValue`; 'text': always the string; 'object': always
+   * the object. `valueChange` always emits the object. A written string is read with `parseAddressValue` for display only: the control keeps
+   * the original text until the user edits a field (so a text the parser cannot split is not rewritten on load).
+   */
+  readonly valueFormat: import("@angular/core").InputSignal<"object" | "text" | "auto">;
+  /** ZIP rule; the default is the US 5 digits / 5+4 rule. `null` accepts any non-empty ZIP. The ZIP is validated and stored trimmed. */
+  readonly zipPattern: import("@angular/core").InputSignal<RegExp | null>;
+  /** Message shown when the ZIP breaks `zipPattern`. */
+  readonly zipError: import("@angular/core").InputSignal<string>;
+  /** Signal-style value (use with `(valueChange)` or `[(value)]`); not needed with ngModel / FormControl. null / undefined = blank. */
+  readonly value: import("@angular/core").InputSignal<string | AddressValue | null | undefined>;
+  /** The `[disabled]` input (also set by the form control through `setDisabledState`). Public so `[disabled]="x"` type-checks in hosts. */
+  readonly _disabledInput: import("@angular/core").InputSignal<boolean>;
+  /** Emits the whole new address when the USER edits a field. Not emitted for written values. */
+  readonly valueChange: import("@angular/core").OutputEmitterRef<AddressValue>;
+  /** Emits whenever the address becomes invalid / valid. */
+  readonly invalidChange: import("@angular/core").OutputEmitterRef<boolean>;
+  private readonly host;
+  private readonly _cvaDisabled;
+  protected readonly disabled: import("@angular/core").Signal<boolean>;
+  protected readonly _v: import("@angular/core").WritableSignal<AddressValue>;
+  private readonly _touched;
+  protected readonly _standalone: {
+    standalone: boolean;
+  };
+  protected readonly _p: import("@angular/core").Signal<string>;
+  private readonly _uid;
+  protected readonly _legendId: string;
+  protected readonly _errorId: string;
+  protected readonly _hintId: string;
+  protected readonly _stateOptions: import("@angular/core").Signal<SelectOption<string>[]>;
+  private readonly _issues;
+  /** True while the address breaks a built-in rule or the host passed an `[error]`. */
+  readonly invalid: import("@angular/core").Signal<boolean>;
+  /** Message of the first broken built-in rule in field order ('' when valid), shown or not. */
+  readonly errorMessage: import("@angular/core").Signal<string>;
+  /** Street, city, state and ZIP are required: always with `required`, and with `requireComplete` once any of them has text. */
+  protected readonly _req: import("@angular/core").Signal<boolean>;
+  protected readonly _describedBy: import("@angular/core").Signal<string | null>;
+  private _onChange;
+  /** True once a string was written to the control (valueFormat 'auto' then emits strings). */
+  private _textModel;
+  /** Fields whose text the USER changed since the last write; only those are trimmed when left. */
+  private readonly _edited;
+  private _onTouched;
+  private _onValidatorChange;
+  constructor();
+  /** Re-run the form control's validation when a rule input (required, maxlength, states, ...) changes. */
+  ngOnChanges(): void;
+  writeValue(val: AddressValue | string | null | undefined): void;
+  registerOnChange(fn: (v: AddressValue | string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(d: boolean): void;
+  registerOnValidatorChange(fn: () => void): void;
+  validate(control: AbstractControl): ValidationErrors | null;
+  protected _set(field: AddressField, text: unknown): void;
+  protected _onFocusOut(field: AddressField, event: FocusEvent): void;
+  /** True while the field's own message may show: `showErrors`, or the field was left. Bound to the child's `showErrors` so a reset clears the child too. */
+  protected _revealed(field: AddressField): boolean;
+  protected _fieldError(field: AddressField): string;
+  private _hasText;
+  private _firstIssue;
+  private _check;
+  private _zipOk;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AddressInputComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AddressInputComponent, "ui-address-input", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "requireComplete": {
+      "alias": "requireComplete";
+      "required": false;
+      "isSignal": true;
+    };
+    "streetLabel": {
+      "alias": "streetLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "unitLabel": {
+      "alias": "unitLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "cityLabel": {
+      "alias": "cityLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "stateLabel": {
+      "alias": "stateLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "zipLabel": {
+      "alias": "zipLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "streetPlaceholder": {
+      "alias": "streetPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "unitPlaceholder": {
+      "alias": "unitPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "cityPlaceholder": {
+      "alias": "cityPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "zipPlaceholder": {
+      "alias": "zipPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "statePlaceholder": {
+      "alias": "statePlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "showUnit": {
+      "alias": "showUnit";
+      "required": false;
+      "isSignal": true;
+    };
+    "states": {
+      "alias": "states";
+      "required": false;
+      "isSignal": true;
+    };
+    "streetMaxlength": {
+      "alias": "streetMaxlength";
+      "required": false;
+      "isSignal": true;
+    };
+    "unitMaxlength": {
+      "alias": "unitMaxlength";
+      "required": false;
+      "isSignal": true;
+    };
+    "cityMaxlength": {
+      "alias": "cityMaxlength";
+      "required": false;
+      "isSignal": true;
+    };
+    "zipMaxlength": {
+      "alias": "zipMaxlength";
+      "required": false;
+      "isSignal": true;
+    };
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+      "isSignal": true;
+    };
+    "showErrors": {
+      "alias": "showErrors";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "idPrefix": {
+      "alias": "idPrefix";
+      "required": false;
+      "isSignal": true;
+    };
+    "prefix": {
+      "alias": "prefix";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueFormat": {
+      "alias": "valueFormat";
+      "required": false;
+      "isSignal": true;
+    };
+    "zipPattern": {
+      "alias": "zipPattern";
+      "required": false;
+      "isSignal": true;
+    };
+    "zipError": {
+      "alias": "zipError";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "_disabledInput": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "valueChange": "valueChange";
+    "invalidChange": "invalidChange";
+  }, never, never, true, never>;
+}
 export type ImagePreviewShape = 'circle' | 'rounded';
 export type ImagePreviewSize = 'sm' | 'md' | 'lg';
 export type ImagePreviewPlaceholder = 'person' | 'image';
@@ -8838,6 +9543,14 @@ export type ImageAlign = 'start' | 'center' | 'end';
  *  - `placeholder` (default true): a neutral icon in the same box when there is no `src` or it fails to load. false renders nothing then.
  *  - `priority`: above-the-fold image - loads eagerly with high fetch priority. Otherwise `loading="lazy"` and async decoding.
  *  - Outputs `loaded` and `failed`. A new `src` (or a changed `retryKey`) gets a fresh chance to load.
+ *  - Library source 2026-11-04, not yet published: `[interactive]="true"` makes the image a button (e.g. a product photo that opens a preview):
+ *    the host gets `role="button"`, `tabindex="0"`, a focus ring, and click, Enter or Space emit `(activate)`. Its accessible name is the `alt`
+ *    text (also set as `aria-label`), so an interactive image NEEDS a non-empty `alt` (a decorative `alt=""` image would be an unnamed button). Not
+ *    interactive (default) = no role, no tabindex, no key handling, no output: exactly as before.
+ *    Inside a clickable parent (e.g. a pressable `ui-list-item` row via the `list-item-image` slot) the click bubbles: `activate` fires AND the parent's
+ *    own click handling runs (the row is selected). Enter / Space fire `activate` only; the parent's key handlers that require their own element as the
+ *    target (`ui-list-item`) ignore them.
+ *      <ui-image [src]="p.photo" [alt]="'Open photo of ' + p.name" [interactive]="true" (activate)="preview(p)" />
  */
 export declare class ImageComponent {
   /** Image URL (or data URL). Blank shows the placeholder. */
@@ -8864,8 +9577,15 @@ export declare class ImageComponent {
   readonly priority: import("@angular/core").InputSignal<boolean>;
   /** Bump to retry a failed image with the same `src`. */
   readonly retryKey: import("@angular/core").InputSignal<unknown>;
+  /**
+   * Library source 2026-11-04, not yet published. `true` = the image is a button: `role="button"`, `tabindex="0"`, `aria-label` from `alt`, and click /
+   * Enter / Space emit `activate`. Needs a non-empty `alt` (it is the button's name). Default `false` = a plain image, nothing changes.
+   */
+  readonly interactive: import("@angular/core").InputSignal<boolean>;
   readonly loaded: import("@angular/core").OutputEmitterRef<void>;
   readonly failed: import("@angular/core").OutputEmitterRef<void>;
+  /** Fires (once per press) when an `interactive` image is clicked, or Enter / Space is pressed on it. Never fires when not interactive. */
+  readonly activate: import("@angular/core").OutputEmitterRef<void>;
   protected readonly _failed: import("@angular/core").WritableSignal<boolean>;
   protected readonly _url: import("@angular/core").Signal<string | null>;
   protected readonly radiusCss: import("@angular/core").Signal<string>;
@@ -8877,6 +9597,8 @@ export declare class ImageComponent {
   protected readonly isBlock: import("@angular/core").Signal<boolean>;
   constructor();
   protected _onError(): void;
+  protected onActivate(): void;
+  protected onKey(event: Event): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<ImageComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<ImageComponent, "ui-image", never, {
     "src": {
@@ -8954,9 +9676,15 @@ export declare class ImageComponent {
       "required": false;
       "isSignal": true;
     };
+    "interactive": {
+      "alias": "interactive";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "loaded": "loaded";
     "failed": "failed";
+    "activate": "activate";
   }, never, never, true, never>;
 }
 /** One picture of a `ui-image-gallery`. */
@@ -9175,6 +9903,17 @@ export declare class KpiCardComponent {
   readonly highlight: import("@angular/core").InputSignal<boolean>;
   readonly clickable: import("@angular/core").InputSignal<boolean>;
   readonly valueColor: import("@angular/core").InputSignal<KpiCardValueColor>;
+  /**
+   * (library source 2026-11-04, not yet published) While true the value (and the subtitle, when one is set) are replaced by grey
+   * placeholders and the card is `aria-busy="true"`; assistive tech reads the label followed by the `loadingLabel` text
+   * (visually hidden), never the stale value or subtitle. The card keeps its size: the value placeholder has the value line's box and the
+   * subtitle placeholder is the subtitle's own (transparent) text, so pass the subtitle you will show while loading to keep the height
+   * identical. The progress ring (when there is one) stays visible but is hidden from assistive tech (`aria-hidden="true"` on it) while loading, since its
+   * value belongs to the data that is being replaced. Default false = unchanged. Everything else (icon, ring, `kpi-footer` slot, `clickable`, colours) is unaffected.
+   */
+  readonly loading: import("@angular/core").InputSignal<boolean>;
+  /** What assistive tech hears instead of the value while `loading` (default 'Loading'). */
+  readonly loadingLabel: import("@angular/core").InputSignal<string>;
   /** Card background as any CSS colour (`#fef2f2`, `var(--surface)` …). Empty (default) = white. The text colours do not change, so use a light shade. */
   readonly background: import("@angular/core").InputSignal<string>;
   /** Completed amount shown as a `ui-progress-ring` beside the label. `null` (default) = no ring. */
@@ -9236,6 +9975,16 @@ export declare class KpiCardComponent {
       "required": false;
       "isSignal": true;
     };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadingLabel": {
+      "alias": "loadingLabel";
+      "required": false;
+      "isSignal": true;
+    };
     "background": {
       "alias": "background";
       "required": false;
@@ -9547,6 +10296,12 @@ export declare function humanReadableMessage(value: unknown): string | null;
 export declare class RadioComponent {
   readonly label: import("@angular/core").InputSignal<string>;
   readonly description: import("@angular/core").InputSignal<string>;
+  /**
+   * Library source 2026-11-04, not yet published. Optional icon drawn in front of the label: a `<ui-icon>` key (`cup`, `wrench`, `card`, ...) or a raw 24x24
+   * stroke SVG path (`M12 5v14 M5 12h14`). Decorative (`aria-hidden`), so the accessible name stays the label. Empty (default), an unknown key or
+   * text that is not a path = nothing is drawn and the DOM is unchanged.
+   */
+  readonly icon: import("@angular/core").InputSignal<string>;
   /** Accessible name when there is no visible `label`. */
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
   /** `data-testid` of the native radio input; none when empty. */
@@ -9563,6 +10318,8 @@ export declare class RadioComponent {
   /** Public so a host template can bind `[disabled]` (a protected input fails strict template type-checking). */
   readonly _disabledInput: import("@angular/core").InputSignal<boolean>;
   protected readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** Path of the icon: a known icon key, else the text itself when it looks like an SVG path (drawing commands and numbers only), else none. */
+  protected readonly _iconD: import("@angular/core").Signal<string | null>;
   /** Id of the visible label text. Optional: a host (e.g. `ui-radio-group`) can set it to point another element at the label with `aria-labelledby`; a unique id is generated when empty. */
   readonly labelId: import("@angular/core").InputSignal<string>;
   private readonly _generatedLabelId;
@@ -9587,6 +10344,11 @@ export declare class RadioComponent {
       "required": false;
       "isSignal": true;
     };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
     "ariaLabel": {
       "alias": "ariaLabel";
       "required": false;
@@ -10108,6 +10870,9 @@ export declare class PdfHotspotComponent {
  *  - `textColor`: the colour of the title, subtitle, chevron and body text (any CSS colour; default: the normal slate colours). Use it for light text on a dark `background`. Text you colour yourself inside the body keeps its own colour.
  *  - `<ng-container card-footer>` / `<div card-footer>`: a footer bar under the body (a pager, totals, a link). Hidden while empty or collapsed, 10px 18px padding,
  *    a light top line; `footerBackground` colours it (pair it with `headerBackground` to frame the card). In a `fill` card it is pinned to the bottom edge.
+ *  - `footerAlign="end"` (library source 2026-11-04, not yet published): turns the `[card-footer]` bar into a right-aligned action row (flex, `justify-content: flex-end`,
+ *    8px gap, wraps on a narrow card) for one or several buttons under the body, e.g. `<ui-button card-footer variant="secondary" size="sm">Open Resident</ui-button>`.
+ *    Default `'start'` = the footer is unchanged (block content, left-aligned). Hidden while empty or collapsed in both modes.
  *  - The body has built-in padding (16px 18px, matching the header's 18px side padding); there is no padding input.
  *  - `collapsible` (default true): a chevron toggle and a clickable header; `[(expanded)]` is two-way.
  *    Without a header, or with `collapsible` false, the body is always open.
@@ -10139,7 +10904,7 @@ export declare class DetailCardComponent {
   /** true (default) = the title is displayed in capitals (CSS only); false = shown as written. The text, aria-label and heading name are never changed. */
   readonly uppercaseTitle: import("@angular/core").InputSignal<boolean>;
   /** 1-6 makes the title a real heading for screen readers (role=heading, aria-level); null keeps it plain text. */
-  readonly headingLevel: import("@angular/core").InputSignal<1 | 2 | 3 | 4 | 5 | 6 | null>;
+  readonly headingLevel: import("@angular/core").InputSignal<2 | 1 | 5 | 3 | 4 | 6 | null>;
   /** Optional id for the title text; the card is then labelled by it. Without it the title is the card's aria-label. */
   readonly titleId: import("@angular/core").InputSignal<string>;
   /** Accessible name of the card when the header gives none (no header, or no title). A visible title wins; blank = no name. */
@@ -10152,6 +10917,8 @@ export declare class DetailCardComponent {
   readonly headerBackground: import("@angular/core").InputSignal<string>;
   /** Background colour of the footer bar (the `[card-footer]` slot) as any CSS colour. Empty = no colour of its own. */
   readonly footerBackground: import("@angular/core").InputSignal<string>;
+  /** Alignment of the `[card-footer]` content: `'start'` (default, unchanged) or `'end'` = a right-aligned action row with an 8px gap. */
+  readonly footerAlign: import("@angular/core").InputSignal<"end" | "start">;
   /** Text colour as any CSS colour (`#fff`, `var(--on-dark)` …). Empty = the default colours. Colours the title, subtitle, chevron and body text. */
   readonly textColor: import("@angular/core").InputSignal<string>;
   /** false = no header at all (no title, edit button, toggle or divider): the card is only the body, always open. */
@@ -10238,6 +11005,11 @@ export declare class DetailCardComponent {
       "required": false;
       "isSignal": true;
     };
+    "footerAlign": {
+      "alias": "footerAlign";
+      "required": false;
+      "isSignal": true;
+    };
     "textColor": {
       "alias": "textColor";
       "required": false;
@@ -12322,6 +13094,12 @@ export declare function todayInTimezone(timezone?: string | null): string;
  * download). A no-op without a DOM (server-side rendering).
  */
 export declare function downloadBlob(blob: Blob, fileName: string): void;
+/**
+ * The file name of a `Content-Disposition` header (`attachment; filename="a.zip"`, `filename=a.zip` or the encoded `filename*=UTF-8''a%20b.zip`),
+ * or '' when the header is missing or names no file. Path separators and leading dots are removed so a server name can never point outside the
+ * downloads folder.
+ */
+export declare function fileNameFromContentDisposition(header: string | null | undefined): string;
 /**
  * A lightbox: a `ui-modal` that shows a `ui-image-gallery` with a Close button in the footer.
  *
@@ -12743,7 +13521,7 @@ export declare class SetupWizardComponent {
   protected customHintId(): string;
   protected readonly importBlocked: import("@angular/core").Signal<boolean>;
   /** The step's own two parts (`splitLayout`) show as two tabs, one card at a time; this is the open one (it starts on the app's part on every visit). */
-  protected readonly splitTab: import("@angular/core").WritableSignal<"main" | "extra">;
+  protected readonly splitTab: import("@angular/core").WritableSignal<"extra" | "main">;
   protected readonly splitTabs: import("@angular/core").Signal<{
     key: string;
     label: string;
@@ -14550,4 +15328,601 @@ export declare class ConversationsComponent {
     "messagesRetry": "messagesRetry";
   }, never, ["[uiConversationsContext]"], true, never>;
 }
-export type { CalendarAgendaGroup, CalendarDay, CalendarDayLevel, CalendarRange, CalendarViewMode };
+/**
+ * Types and pure helpers of `ui-payment-side-panel`. Nothing here knows a payment processor: Stripe / Square arrive as plugins
+ * (`PaymentMethodPlugin`), the card-present terminal as host callbacks.
+ */
+/** Well-known method values the panel gives behaviour to. Hosts may list any other value (it is recorded like Cash). */
+export declare const PAYMENT_METHOD: {
+  readonly CARD: "CARD";
+  readonly ACH: "ACH";
+  readonly CASH: "CASH";
+  readonly CHECK: "CHECK";
+  readonly MONEY_ORDER: "MONEY_ORDER";
+  readonly CARD_PRESENT: "CARD_PRESENT";
+};
+interface PaymentMethodOption {
+  value: string;
+  label: string;
+  /** `'terminal'`: listed only while the host gave the terminal callbacks (`listReaders` + `startTerminalPayment`). */
+  requires?: 'terminal';
+}
+/** The methods listed when the host gives none: Card and ACH are record-only until a processor plugin takes them over. */
+export declare const DEFAULT_PAYMENT_METHODS: readonly PaymentMethodOption[];
+interface PayableCharge {
+  id: string;
+  chargeType: string;
+  description: string;
+  /** ISO date `YYYY-MM-DD`. */
+  dueDate: string;
+  balanceDue: number;
+}
+interface SavedPaymentMethod {
+  method: string;
+  last4: string;
+  label?: string;
+}
+interface AllocationModeOption {
+  value: string;
+  label: string;
+}
+export declare const ALLOCATION_CUSTOM = "custom";
+export declare const DEFAULT_ALLOCATION_MODES: readonly AllocationModeOption[];
+interface ChargeAllocation {
+  chargeId: string;
+  amount: number;
+}
+/**
+ * How the payment is applied to charges. A non-custom mode sends `{ allocationMode }`. "Choose charges" sends `{ allocationChargeIds, allocations }`
+ * (no `allocationMode`, like the old drawer); `allocations` carries the amount per charge.
+ */
+interface PaymentAllocation {
+  allocationMode?: string;
+  allocationChargeIds?: string[];
+  allocations?: ChargeAllocation[];
+}
+interface PaymentEntry {
+  paymentMethod: string;
+  amount: number;
+  /** Check number / last 4 digits; `null` when the method has none. */
+  reference: string | null;
+  /** The receipt checkbox applies to the LAST entry only (like the old drawer); earlier split entries are `false`. */
+  sendReceipt: boolean;
+}
+interface RecordPaymentPayload extends PaymentAllocation {
+  /** Total of all entries. */
+  amount: number;
+  /** The method of a single payment, `'SPLIT'` when `split`. */
+  paymentMethod: string;
+  receivedDate: string;
+  /** Reference of the single payment (`null` for a split: see `entries`). */
+  reference: string | null;
+  notes: string | null;
+  sendReceipt: boolean;
+  /** One per payment to create (the host posts one request per entry, or one request with all). */
+  entries: PaymentEntry[];
+  split: boolean;
+}
+interface RecordPaymentResult {
+  type: 'manual' | 'stripe' | 'split';
+  paymentMethod: string;
+  amount: number;
+}
+/** What the panel reports for the host to word (toasts, analytics). It never toasts itself. */
+type PaymentPanelOutcome = {
+  kind: 'recorded';
+  result: RecordPaymentResult;
+} | {
+  kind: 'split-recorded';
+  result: RecordPaymentResult;
+} | {
+  kind: 'terminal-paid';
+  result: RecordPaymentResult;
+} | {
+  kind: 'plugin';
+  method: string;
+  code: string;
+  result?: RecordPaymentResult;
+  message?: string;
+} | {
+  kind: 'failed';
+  stage: 'record' | 'readers' | 'terminal';
+  message: string;
+};
+type HostResult<T> = Observable<T> | Promise<T> | T;
+type RecordPaymentFn = (payload: RecordPaymentPayload) => HostResult<unknown>;
+interface TerminalReader {
+  id: string;
+  label?: string;
+  status: string;
+  deviceType?: string;
+}
+interface TerminalStartContext extends PaymentAllocation {
+  readerId: string;
+  amount: number;
+  receivedDate: string;
+  notes: string | null;
+}
+interface TerminalStartResult {
+  paymentIntentId: string;
+}
+interface TerminalStatusResult {
+  status: string;
+}
+interface TerminalConfirmContext extends TerminalStartContext {
+  paymentIntentId: string;
+}
+type TerminalPhase = 'idle' | 'waiting' | 'confirming' | 'success';
+/** Reader statuses that end the wait. */
+export declare function terminalVerdict(status: string | null | undefined): 'succeeded' | 'canceled' | 'declined' | 'pending';
+export declare function terminalTimeoutText(ms: number): string;
+export declare const MIN_PAYMENT_AMOUNT = 0.01;
+export declare const MAX_PAYMENT_AMOUNT = 99999.99;
+declare const toCents: (value: number) => number;
+declare const fromCents: (cents: number) => number;
+declare const roundMoney: (value: number) => number;
+/** A payable amount: a finite number from 0.01 to `max` with at most two decimals. */
+export declare function isValidAmount(value: unknown, max?: number): value is number;
+declare function sumMoney(values: readonly number[]): number;
+declare function referenceKind(method: string, live: boolean): 'check' | 'last4-card' | 'last4-account' | null;
+/** The last-4 box accepts digits only (blank is fine). */
+export declare function last4Error(value: string): string;
+declare function last4Digits(value: string, max?: number): string;
+interface AllocationCheck {
+  general: string;
+  perCharge: Record<string, string>;
+}
+type SelectedCharges = Record<string, number | null>;
+declare function allocationCheck(charges: readonly PayableCharge[], selected: SelectedCharges, totalPayment: number | null, format: (n: number) => string): AllocationCheck;
+/** The amount to propose when a charge is ticked: its balance, capped by what is left of the payment. */
+declare function defaultChargeAmount(charge: PayableCharge, selected: SelectedCharges, totalPayment: number | null): number | null;
+declare function buildAllocation(mode: string, charges: readonly PayableCharge[], selected: SelectedCharges): PaymentAllocation;
+/** "2026-11-03" -> "Nov 3, 2026" without `Date` string parsing (Safari-safe, time-zone independent). */
+declare function formatDueDate(iso: string, locale?: string): string;
+/** Runs a host callback that may return an Observable, a Promise or a value; a synchronous throw becomes a rejection. */
+export declare function callHost<T>(thunk: () => HostResult<T>): Promise<T>;
+/** The text of a failed host call: its HTTP body message, its message, else the fallback. */
+export declare function hostErrorMessage(err: unknown, fallback: string): string;
+/** A method a plugin contributes to the panel's method select (while the plugin is rendered inside the panel). */
+export interface PaymentPluginMethod {
+  value: string;
+  label: string;
+}
+/** The footer button a plugin body may ask the panel to show instead of the panel's own (the panel's own button is hidden for plugin methods). */
+export interface PaymentPluginPrimary {
+  label: string;
+  disabled?: boolean;
+  loading?: boolean;
+  onClick: () => void;
+}
+/**
+ * What the panel hands to a plugin body (`<ng-template let-ctx>`). The values are a snapshot that is replaced whenever the form changes (read them in the
+ * template or in an `input()` of a child component); the functions are stable.
+ */
+export interface PaymentMethodContext {
+  /** The selected method value (one of the plugin's `methods`). */
+  readonly method: string;
+  /** The entered amount, or `null` while it is empty or invalid (a plugin should not start a charge without it). */
+  readonly amount: number | null;
+  /** ISO date the payment was received. */
+  readonly receivedDate: string;
+  readonly note: string;
+  /** How the payment is applied to charges (same shape the manual payload carries). */
+  readonly allocation: PaymentAllocation;
+  /** ISO 4217 code of the panel (`'USD'`). */
+  readonly currency: string;
+  /** Every field of the panel is valid (amount, date, note, allocation). */
+  readonly valid: boolean;
+  /** Reveals the panel's field errors (as a failed Save click does) and returns whether the form is valid. Call it before starting a charge. */
+  validate(): boolean;
+  /** Clears the whole form (method, amount, note, split, allocation; the date returns to today). */
+  reset(): void;
+  /** The payment is done: the panel reports it (`outcome` kind `'plugin'`, code `'complete'`, then `recorded`). Defaults: type `'manual'`, the selected method, the entered amount. Runs once. */
+  complete(result?: Partial<RecordPaymentResult>): void;
+  /** A flow is running: the fields are locked and the method cannot be changed. */
+  setBusy(busy: boolean): void;
+  /** The plugin's own footer button (e.g. "Pay $120.00"); `null` removes it. The panel's own Save button never shows for a plugin method. */
+  setPrimary(button: PaymentPluginPrimary | null): void;
+  /** Hide the panel's fields and show only the plugin body (e.g. a "payment submitted" notice). */
+  setExclusive(on: boolean): void;
+  /** Called when the body is about to go away unfinished: the panel closes, the method changes, or the plugin is removed. Not called after `complete()`. */
+  onCancel(fn: (() => void) | null): void;
+  /** Tell the host something happened (`outcome` kind `'plugin'`) so it can word a toast. */
+  report(code: string, extra?: {
+    result?: RecordPaymentResult;
+    message?: string;
+  }): void;
+  /** Text for the panel's screen-reader status region. */
+  announce(text: string): void;
+}
+export interface PaymentMethodBodyContext {
+  $implicit: PaymentMethodContext;
+}
+/**
+ * The contract of a payment plugin: a child element of `<ui-payment-side-panel>` that contributes live methods (Stripe, Square, ...).
+ * The panel finds plugins with `contentChildren(PAYMENT_METHOD_PLUGIN)`, so presence IS the opt-in; remove the element and its methods leave the select.
+ * A plugin whose method value is `CARD` or `ACH` replaces the record-only behaviour (last 4 digits) of that value while it is rendered.
+ */
+export declare abstract class PaymentMethodPlugin {
+  abstract readonly methods: Signal<readonly PaymentPluginMethod[]>;
+  /** The body shown under the form while one of the plugin's methods is selected. */
+  abstract readonly template: Signal<TemplateRef<PaymentMethodBodyContext> | undefined>;
+}
+export declare const PAYMENT_METHOD_PLUGIN: InjectionToken<PaymentMethodPlugin>;
+/**
+ * The generic payment plugin: the host renders the body of a method it built itself (Square Web SDK, a gateway widget, ...).
+ *
+ *   <ui-payment-side-panel ...>
+ *     <ui-payment-custom-method value="CARD" label="Card">
+ *       <ng-template let-ctx> <my-square-card [amount]="ctx.amount" (paid)="ctx.complete({ type: 'stripe' })" /> </ng-template>
+ *     </ui-payment-custom-method>
+ *   </ui-payment-side-panel>
+ */
+export declare class PaymentCustomMethodComponent extends PaymentMethodPlugin {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  private readonly body;
+  readonly methods: import("@angular/core").Signal<readonly PaymentPluginMethod[]>;
+  readonly template: import("@angular/core").Signal<TemplateRef<PaymentMethodBodyContext> | undefined>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PaymentCustomMethodComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PaymentCustomMethodComponent, "ui-payment-custom-method", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, ["body"], never, true, never>;
+}
+interface SplitEntry {
+  method: string;
+  amount: number;
+  reference: string;
+}
+/**
+ * Side panel for staff to RECORD or COLLECT a payment. Works on its own (record-only: Cash, Check, Money Order, Card and ACH with the last 4 digits) and grows
+ * by PLUGINS the host drops in as child elements (`ui-payment-stripe-method` from `@forgeroute/ui/stripe`, `ui-payment-custom-method` for Square or any widget):
+ * a plugin's presence IS the opt-in, and a plugin method with the value `CARD` / `ACH` replaces the record-only behaviour while it is rendered.
+ * The panel has no HTTP and no processor knowledge: the host gives callbacks (`recordPayment`, the terminal calls) and words the `outcome` events.
+ *
+ *   <ui-payment-side-panel [open]="open()" [today]="today()" [outstandingBalance]="due()" [charges]="charges()"
+ *     [recordPayment]="record" (recorded)="onRecorded($event)" (closed)="open.set(false)" />
+ *
+ * See docs/payment-side-panel.md.
+ */
+export declare class PaymentSidePanelComponent {
+  private readonly injector;
+  private readonly hostEl;
+  protected readonly ids: string;
+  protected readonly customMode = "custom";
+  readonly open: import("@angular/core").InputSignal<boolean>;
+  readonly title: import("@angular/core").InputSignal<string>;
+  readonly subtitle: import("@angular/core").InputSignal<string>;
+  /** Today as `YYYY-MM-DD` (the host's clock/time zone): the default Received Date. The panel never builds dates itself. */
+  readonly today: import("@angular/core").InputSignal<string>;
+  /** When > 0 a banner shows it and the amount starts at this balance. */
+  readonly outstandingBalance: import("@angular/core").InputSignal<number | null>;
+  /** ISO 4217 code used for every amount shown. */
+  readonly currency: import("@angular/core").InputSignal<string>;
+  readonly maxAmount: import("@angular/core").InputSignal<number>;
+  /** Latest Received Date (ISO). Default: `today`, because a payment cannot be received in the future. */
+  readonly maxDate: import("@angular/core").InputSignal<string>;
+  /** The methods listed (value/label). Default: Card, ACH / Bank Transfer, Cash, Check, Money Order, Card Present (terminal callbacks given). */
+  readonly methods: import("@angular/core").InputSignal<readonly PaymentMethodOption[]>;
+  readonly savedMethods: import("@angular/core").InputSignal<readonly SavedPaymentMethod[]>;
+  readonly charges: import("@angular/core").InputSignal<readonly PayableCharge[]>;
+  readonly allocationModes: import("@angular/core").InputSignal<readonly AllocationModeOption[]>;
+  readonly defaultAllocationMode: import("@angular/core").InputSignal<string>;
+  /** Text of the "send receipt" checkbox (e.g. "Email receipt to resident"); empty hides it. */
+  readonly receiptLabel: import("@angular/core").InputSignal<string>;
+  readonly submitLabel: import("@angular/core").InputSignal<string>;
+  readonly splitSubmitLabel: import("@angular/core").InputSignal<string>;
+  /** Records the payment. Returns an Observable / Promise; a rejection is shown in the panel and it stays open. */
+  readonly recordPayment: import("@angular/core").InputSignal<RecordPaymentFn | null>;
+  readonly listReaders: import("@angular/core").InputSignal<(() => HostResult<readonly TerminalReader[]>) | null>;
+  readonly startTerminalPayment: import("@angular/core").InputSignal<((ctx: TerminalStartContext) => HostResult<TerminalStartResult>) | null>;
+  readonly terminalStatus: import("@angular/core").InputSignal<((paymentIntentId: string) => HostResult<TerminalStatusResult>) | null>;
+  readonly confirmTerminalPayment: import("@angular/core").InputSignal<((ctx: TerminalConfirmContext) => HostResult<unknown>) | null>;
+  readonly cancelTerminal: import("@angular/core").InputSignal<((readerId: string) => HostResult<unknown>) | null>;
+  readonly terminalProvider: import("@angular/core").InputSignal<string>;
+  readonly noReadersText: import("@angular/core").InputSignal<string>;
+  readonly terminalPollMs: import("@angular/core").InputSignal<number>;
+  readonly terminalTimeoutMs: import("@angular/core").InputSignal<number>;
+  readonly readerRefreshMs: import("@angular/core").InputSignal<number>;
+  readonly terminalSuccessDelayMs: import("@angular/core").InputSignal<number>;
+  readonly closed: import("@angular/core").OutputEmitterRef<void>;
+  /** The payment is done (any flow). The host closes the panel. */
+  readonly recorded: import("@angular/core").OutputEmitterRef<RecordPaymentResult>;
+  /** What happened, for the host to word (the panel never toasts). */
+  readonly outcome: import("@angular/core").OutputEmitterRef<PaymentPanelOutcome>;
+  private readonly plugins;
+  private readonly fields;
+  readonly method: import("@angular/core").WritableSignal<string>;
+  readonly amount: import("@angular/core").WritableSignal<number | null>;
+  readonly receivedDate: import("@angular/core").WritableSignal<string>;
+  readonly reference: import("@angular/core").WritableSignal<string>;
+  readonly note: import("@angular/core").WritableSignal<string>;
+  readonly sendReceipt: import("@angular/core").WritableSignal<boolean>;
+  readonly splitEntries: import("@angular/core").WritableSignal<SplitEntry[]>;
+  readonly allocationMode: import("@angular/core").WritableSignal<string>;
+  readonly selectedCharges: import("@angular/core").WritableSignal<SelectedCharges>;
+  readonly touched: import("@angular/core").WritableSignal<boolean>;
+  readonly submitting: import("@angular/core").WritableSignal<boolean>;
+  readonly submitError: import("@angular/core").WritableSignal<string>;
+  readonly announcement: import("@angular/core").WritableSignal<string>;
+  private readonly pluginBusy;
+  protected readonly exclusive: import("@angular/core").WritableSignal<boolean>;
+  private readonly pluginPrimary;
+  private cancelHook;
+  private completed;
+  readonly readers: import("@angular/core").WritableSignal<readonly TerminalReader[]>;
+  readonly readersLoaded: import("@angular/core").WritableSignal<boolean>;
+  readonly loadingReaders: import("@angular/core").WritableSignal<boolean>;
+  readonly readersError: import("@angular/core").WritableSignal<string>;
+  readonly readerId: import("@angular/core").WritableSignal<string>;
+  readonly terminalPhase: import("@angular/core").WritableSignal<TerminalPhase>;
+  readonly terminalError: import("@angular/core").WritableSignal<string>;
+  readonly sendingToReader: import("@angular/core").WritableSignal<boolean>;
+  readonly retryIntentId: import("@angular/core").WritableSignal<string>;
+  readonly retrying: import("@angular/core").WritableSignal<boolean>;
+  readonly terminalAmount: import("@angular/core").WritableSignal<number>;
+  /** Bumped when the form is reset or the panel closes: an async terminal step that finishes later must not touch the new state. */
+  private session;
+  private retryContext;
+  private pollTimer;
+  private pollToken;
+  private refreshTimer;
+  private successTimer;
+  private pendingTerminalResult;
+  private terminalContext;
+  protected readonly busy: import("@angular/core").Signal<boolean>;
+  /** Fields are read-only while something runs, and while a taken terminal payment still has to be recorded (its amount must not change). */
+  protected readonly locked: import("@angular/core").Signal<boolean>;
+  protected readonly dateMax: import("@angular/core").Signal<string>;
+  protected readonly money: (value: number) => string;
+  protected readonly currencySymbol: import("@angular/core").Signal<string>;
+  private readonly terminalAvailable;
+  /** value -> label of every live method the rendered plugins contribute (the first plugin wins a duplicate value). */
+  private readonly liveMethods;
+  protected readonly kind: import("@angular/core").Signal<"none" | "manual" | "live" | "terminal">;
+  private kindOf;
+  /** The method list as shown: record-only built-ins (a plugin takes over its own values), plugin extras, and only manual ones while a split is being built. */
+  readonly methodList: import("@angular/core").Signal<PaymentMethodOption[]>;
+  protected readonly methodOptions: import("@angular/core").Signal<{
+    value: string;
+    label: string;
+  }[]>;
+  protected readonly methodRequired: import("@angular/core").Signal<boolean>;
+  protected readonly allocationOptions: import("@angular/core").Signal<{
+    value: string;
+    label: string;
+  }[]>;
+  /** Hidden while a taken terminal payment still has to be recorded: the method cannot change then. */
+  protected readonly savedChips: import("@angular/core").Signal<SavedPaymentMethod[]>;
+  protected readonly refKind: import("@angular/core").Signal<"check" | "last4-card" | "last4-account" | null>;
+  protected readonly referenceError: import("@angular/core").Signal<string>;
+  private readonly amountValid;
+  protected readonly splitTotal: import("@angular/core").Signal<number>;
+  private readonly totalPayment;
+  protected readonly allocation: import("@angular/core").Signal<AllocationCheck>;
+  private readonly allocationPayload;
+  protected readonly hasInvalid: import("@angular/core").Signal<boolean>;
+  protected readonly canSplit: import("@angular/core").Signal<boolean>;
+  protected readonly readerOptions: import("@angular/core").Signal<{
+    value: string;
+    label: string;
+  }[]>;
+  protected readonly selectedReader: import("@angular/core").Signal<TerminalReader | null>;
+  protected readonly canSendToReader: import("@angular/core").Signal<boolean>;
+  protected readonly pluginTemplate: import("@angular/core").Signal<import("@angular/core").TemplateRef<PaymentMethodBodyContext> | undefined>;
+  protected readonly pluginContext: import("@angular/core").Signal<PaymentMethodBodyContext>;
+  protected readonly primaryLabel: import("@angular/core").Signal<string>;
+  protected readonly primaryLoading: import("@angular/core").Signal<boolean>;
+  protected readonly primaryDisabled: import("@angular/core").Signal<boolean>;
+  constructor();
+  private init;
+  private teardown;
+  private resetForm;
+  /** A card payment the reader took but that was never recorded is being abandoned: the host must hear about it. */
+  private dropPendingRetry;
+  private cleanup;
+  protected onClose(): void;
+  private runCancelHook;
+  protected onMethodChange(value: string | null): void;
+  protected selectSaved(saved: SavedPaymentMethod): void;
+  protected chipLabel(saved: SavedPaymentMethod): string;
+  protected methodLabel(value: string): string;
+  protected onLast4(value: string | null): void;
+  protected addSplit(): void;
+  protected removeSplit(index: number): void;
+  protected onAllocationMode(value: string | null): void;
+  protected isTicked(id: string): boolean;
+  protected toggleCharge(charge: PayableCharge, checked: boolean): void;
+  protected setChargeAmount(id: string, value: number | string | null): void;
+  protected chargeDescription(charge: PayableCharge): string;
+  private referenceFor;
+  private buildEntries;
+  /** The payload the host receives, or `null` when there is nothing valid to record. */
+  buildPayload(): RecordPaymentPayload | null;
+  protected onPrimary(): void;
+  submit(): Promise<void>;
+  /**
+   * A host that posts the entries one by one can tell the panel how many went through before a failure: `throw { message, postedEntries: 1 }`.
+   * Those first entries are removed, so a retry does not post them again.
+   */
+  private dropPostedEntries;
+  private buildContext;
+  private completeFromPlugin;
+  private resetTerminal;
+  private startTerminalSession;
+  protected refreshReaders(): void;
+  private loadReaders;
+  private scheduleReaderRefresh;
+  private stopReaderRefresh;
+  private terminalBase;
+  sendToReader(): Promise<void>;
+  private startPolling;
+  private stopPolling;
+  private endWaiting;
+  private confirmTerminal;
+  /** Repeats the recording for the payment the reader already took, with the amount that was charged (not the form's current values). */
+  protected retryRecording(): Promise<void>;
+  private finishTerminal;
+  protected cancelTerminalPayment(): void;
+  private cancelTerminalIfWaiting;
+  /** Moves focus after the next render (the control that had it was just removed from the DOM). */
+  private focusLater;
+  private fireCancelReader;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PaymentSidePanelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PaymentSidePanelComponent, "ui-payment-side-panel", never, {
+    "open": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "subtitle": {
+      "alias": "subtitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "today": {
+      "alias": "today";
+      "required": false;
+      "isSignal": true;
+    };
+    "outstandingBalance": {
+      "alias": "outstandingBalance";
+      "required": false;
+      "isSignal": true;
+    };
+    "currency": {
+      "alias": "currency";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxAmount": {
+      "alias": "maxAmount";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxDate": {
+      "alias": "maxDate";
+      "required": false;
+      "isSignal": true;
+    };
+    "methods": {
+      "alias": "methods";
+      "required": false;
+      "isSignal": true;
+    };
+    "savedMethods": {
+      "alias": "savedMethods";
+      "required": false;
+      "isSignal": true;
+    };
+    "charges": {
+      "alias": "charges";
+      "required": false;
+      "isSignal": true;
+    };
+    "allocationModes": {
+      "alias": "allocationModes";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultAllocationMode": {
+      "alias": "defaultAllocationMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "receiptLabel": {
+      "alias": "receiptLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "submitLabel": {
+      "alias": "submitLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "splitSubmitLabel": {
+      "alias": "splitSubmitLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "recordPayment": {
+      "alias": "recordPayment";
+      "required": false;
+      "isSignal": true;
+    };
+    "listReaders": {
+      "alias": "listReaders";
+      "required": false;
+      "isSignal": true;
+    };
+    "startTerminalPayment": {
+      "alias": "startTerminalPayment";
+      "required": false;
+      "isSignal": true;
+    };
+    "terminalStatus": {
+      "alias": "terminalStatus";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirmTerminalPayment": {
+      "alias": "confirmTerminalPayment";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelTerminal": {
+      "alias": "cancelTerminal";
+      "required": false;
+      "isSignal": true;
+    };
+    "terminalProvider": {
+      "alias": "terminalProvider";
+      "required": false;
+      "isSignal": true;
+    };
+    "noReadersText": {
+      "alias": "noReadersText";
+      "required": false;
+      "isSignal": true;
+    };
+    "terminalPollMs": {
+      "alias": "terminalPollMs";
+      "required": false;
+      "isSignal": true;
+    };
+    "terminalTimeoutMs": {
+      "alias": "terminalTimeoutMs";
+      "required": false;
+      "isSignal": true;
+    };
+    "readerRefreshMs": {
+      "alias": "readerRefreshMs";
+      "required": false;
+      "isSignal": true;
+    };
+    "terminalSuccessDelayMs": {
+      "alias": "terminalSuccessDelayMs";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closed": "closed";
+    "recorded": "recorded";
+    "outcome": "outcome";
+  }, ["plugins"], never, true, never>;
+}
+export type { AllocationModeOption, CalendarAgendaGroup, CalendarDay, CalendarDayLevel, CalendarRange, CalendarViewMode, ChargeAllocation, HostResult, PayableCharge, PaymentAllocation, PaymentEntry, PaymentMethodOption, PaymentPanelOutcome, RecordPaymentFn, RecordPaymentPayload, RecordPaymentResult, SavedPaymentMethod, TerminalConfirmContext, TerminalPhase, TerminalReader, TerminalStartContext, TerminalStartResult, TerminalStatusResult };