@forgeroute/ui 0.4.71 → 0.4.72

package/types/forgeroute-ui.d.ts

@@ -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,8 @@ 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>;
+  /** 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`). */
@@ -1152,6 +1203,11 @@ export declare class SelectComponent implements ControlValueAccessor, Validator,
       "required": false;
       "isSignal": true;
     };
+    "inputName": {
+      "alias": "inputName";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -1540,6 +1596,11 @@ 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. */
   readonly rowDeleted: import("@angular/core").OutputEmitterRef<T>;
   /**
@@ -1763,6 +1824,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 +1836,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 +2192,7 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
     "selectionChange": "selectionChange";
     "tabChange": "tabChange";
     "bulkAction": "bulkAction";
+    "bulkPanelClick": "bulkPanelClick";
     "rowDeleted": "rowDeleted";
     "rowReorder": "rowReorder";
   }, never, never, true, never>;
@@ -2158,7 +2228,7 @@ export declare class SidePanelComponent implements OnDestroy {
   readonly cancelLabel: import("@angular/core").InputSignal<string>;
   /** Right-aligned primary action button label. Empty string = hidden. */
   readonly primaryLabel: import("@angular/core").InputSignal<string>;
-  readonly primaryVariant: import("@angular/core").InputSignal<"primary" | "danger" | "warning">;
+  readonly primaryVariant: import("@angular/core").InputSignal<"warning" | "danger" | "primary">;
   readonly primaryLoading: import("@angular/core").InputSignal<boolean>;
   readonly primaryDisabled: import("@angular/core").InputSignal<boolean>;
   /** `data-testid` of the Cancel button; none when empty (default). */
@@ -2272,7 +2342,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. */
@@ -2830,7 +2900,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>;
@@ -3482,7 +3552,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. */
@@ -4111,7 +4181,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" | "icon" | "warning" | "danger" | "primary" | "secondary" | "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' }`). */
@@ -4157,7 +4227,7 @@ export declare class ButtonComponent {
   readonly color: import("@angular/core").InputSignal<string | undefined>;
   readonly active: import("@angular/core").InputSignal<boolean>;
   readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg" | "xs">;
-  readonly type: import("@angular/core").InputSignal<"reset" | "submit" | "button">;
+  readonly type: import("@angular/core").InputSignal<"button" | "reset" | "submit">;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   readonly loading: import("@angular/core").InputSignal<boolean>;
   readonly fullWidth: import("@angular/core").InputSignal<boolean>;
@@ -4608,7 +4678,7 @@ export declare class BulkMessagePanelComponent {
   readonly sending: import("@angular/core").InputSignal<boolean>;
   readonly closed: import("@angular/core").OutputEmitterRef<void>;
   readonly send: import("@angular/core").OutputEmitterRef<BulkMessageSendEvent>;
-  readonly channel: import("@angular/core").WritableSignal<"text" | "email">;
+  readonly channel: import("@angular/core").WritableSignal<"email" | "text">;
   private readonly _subject;
   private readonly _body;
   get subject(): string;
@@ -5082,6 +5152,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
@@ -5101,7 +5173,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" | "email" | "text" | "tel" | "password" | "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 +5182,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" | "email" | "search" | "text" | "numeric" | "tel" | "url" | "decimal">;
   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. */
@@ -5176,7 +5248,7 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
   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" | "email" | "text" | "tel" | "password" | "url">;
   protected readonly _eyePath: string;
   protected readonly _eyeOffPath: string;
   protected readonly _showRequirements: import("@angular/core").Signal<boolean>;
@@ -5240,6 +5312,11 @@ export declare class TextInputComponent implements ControlValueAccessor, Validat
       "required": false;
       "isSignal": true;
     };
+    "inputName": {
+      "alias": "inputName";
+      "required": false;
+      "isSignal": true;
+    };
     "placeholder": {
       "alias": "placeholder";
       "required": false;
@@ -6996,7 +7073,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, {
@@ -7046,7 +7123,7 @@ export type ListItemDetail = string | {
 export type ListItemIconColor = 'slate' | 'amber' | 'red' | 'blue' | 'green' | 'purple' | 'teal' | 'orange';
 export declare class ListItemComponent {
   /** 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). */
@@ -8538,7 +8615,7 @@ export declare class IconComponent {
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
   /** Icon size in px. */
   readonly size: import("@angular/core").InputSignal<number>;
-  readonly variant: import("@angular/core").InputSignal<"danger" | "default">;
+  readonly variant: import("@angular/core").InputSignal<"default" | "danger">;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   /** The host is running the request this icon started: a spinner replaces the picture and the button is disabled (no click) until it is false again. */
   readonly loading: import("@angular/core").InputSignal<boolean>;
@@ -8650,7 +8727,7 @@ export declare class TimelineComponent {
   /** Any CSS length (e.g. `600px`). When set, the list scrolls inside a keyboard-focusable region of at most this height. Empty = no wrapper. */
   readonly maxHeight: import("@angular/core").InputSignal<string>;
   /** `below` (default): the time is under the title / description. `end`: the time sits right-aligned on the title row. */
-  readonly timePosition: import("@angular/core").InputSignal<"end" | "below">;
+  readonly timePosition: import("@angular/core").InputSignal<"below" | "end">;
   /**
    * Group the items under a heading per calendar day of `dateTime` ("Today", "Yesterday", "Oct 3", "Oct 3, 2025"). Default false = no headings,
    * DOM unchanged. The given order is kept: consecutive items of one day share a heading, the same day appearing again later starts a new group.
@@ -8731,6 +8808,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';
@@ -10005,7 +10417,7 @@ export declare class PdfHotspotComponent {
   /** `ready`: clickable; `blocked`: disabled (a prerequisite is missing); `signed`: shows `image`. */
   readonly state: import("@angular/core").InputSignal<"ready" | "blocked" | "signed">;
   /** `warning` gives the ready state an amber look (e.g. for initials), default is blue. */
-  readonly tone: import("@angular/core").InputSignal<"primary" | "warning">;
+  readonly tone: import("@angular/core").InputSignal<"warning" | "primary">;
   /** Text of the ready button (e.g. "Sign Here"). */
   readonly label: import("@angular/core").InputSignal<string>;
   /** Text of the blocked button (e.g. "Add signature above"). */
@@ -12322,6 +12734,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.
  *
@@ -14550,4 +14968,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" | "live" | "terminal" | "manual">;
+  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 };