@forgeroute/ui 0.3.8 → 0.3.9

package/types/forgeroute-ui.d.ts

@@ -105,6 +105,16 @@ export interface ColumnDef {
   label: string;
   sortable?: boolean;
   defaultVisible?: boolean;
+  /**
+   * Wire name of this column's FILTER, when it must differ from `key`. Defaults to `key` (unset = unchanged behaviour).
+   * Replaces `key` only for: the column-filter query param on rows and export requests, the key read from the
+   * `/filter-counts` response for this column's options/counts (also the bulk "Change <column>" options), and the key
+   * stored in saved views (a view saved under the plain `key` still restores). Everything else stays on `key`:
+   * sort (`sort=<key>`), cell values, visibility, `lockedColumn`, `searchFields`, `bulkUpdateOptions` and the
+   * `/bulk/<field>` request body. It also names the header filter and the phone-card filter chips' request param. It must not equal a reserved table param (`page`, `size`, `search`, `searchFields`, `sort`, `direction`, `filter`) nor an `Object.prototype` member name such as `constructor` — there is no runtime guard. Example: `{ key: 'direction', filterParam: 'messageDirection' }` keeps the filter
+   * from colliding with the table's own `direction=asc|desc` sort param.
+   */
+  filterParam?: string;
   /** If true, this column's label appears in the search input placeholder when the column is visible. */
   searchable?: boolean;
   /** Values a bulk "Change <label>" may set. When omitted the options come from /filter-counts.
@@ -615,17 +625,56 @@ export declare class MoreMenuComponent {
   protected readonly openUp: import("@angular/core").WritableSignal<boolean>;
   /** Caps the dropdown to the space on the side it opens, so it never runs off-screen; it scrolls instead. */
   protected readonly maxHeight: import("@angular/core").WritableSignal<number | null>;
+  /** Caps a fixed dropdown to the visible width minus 8px each side (the CSS cap uses 100vw, which includes classic scrollbars). */
+  protected readonly maxWidth: import("@angular/core").WritableSignal<number | null>;
+  /**
+   * Viewport placement (px) of a `position: fixed` dropdown; null = the dropdown is positioned absolutely under the trigger
+   * (an ancestor with a transform / filter / contain makes `fixed` unusable there).
+   */
+  protected readonly placement: import("@angular/core").WritableSignal<{
+    top: number | null;
+    bottom: number | null;
+    right: number;
+  } | null>;
   private readonly _el;
+  private readonly _cdr;
+  /** Width of the window when the menu opened: a resize that keeps it (the on-screen keyboard, a collapsing address bar) does not close the menu. */
+  private _openWidth;
+  constructor();
   protected readonly visibleActions: () => RowAction[];
   protected resolveIcon(action: RowAction): string;
   protected isDisabled(action: RowAction): boolean;
   toggle(event: Event): void;
+  /**
+   * Decides where the open dropdown goes: below the trigger when its real height fits, otherwise above when there is more
+   * room there, capped to the room on that side (it scrolls inside). Measured against the visible window (the on-screen
+   * keyboard and pinch-zoom shrink it, and the home-indicator safe area is kept clear), or, when `position: fixed` is not
+   * usable, against the nearest scrolling ancestor. A fixed dropdown also stays inside the screen horizontally.
+   */
+  private _place;
+  /**
+   * The layout viewport: the box `position: fixed` offsets are measured from. It excludes scrollbars and ignores pinch-zoom,
+   * unlike `window.innerWidth / innerHeight`.
+   */
+  private _layoutViewport;
+  /** The part of the page that is actually visible (shrinks with the on-screen keyboard and pinch-zoom on phones). */
+  private _viewport;
+  /** Height of the bottom safe area (home indicator) in px; 0 where there is none. */
+  protected _safeAreaBottom(): number;
   onActionClick(action: RowAction, event: Event): void;
   onDocumentClick(): void;
+  /** A touch or mouse press anywhere outside the menu closes it (more reliable than a click on phones: iOS does not send clicks for plain page areas). */
+  onDocumentPointerDown(event: Event): void;
   onEscape(): void;
   onArrow(event: Event, dir: 1 | -1): void;
   /** Visible top/bottom of the nearest scrolling ancestor, clipped to the viewport. */
   private _visibleBounds;
+  /**
+   * False when an ancestor creates a containing block for `position: fixed` (transform and the individual translate / rotate / scale,
+   * filter, perspective, backdrop-filter, contain, container-type, content-visibility, will-change naming any of those).
+   */
+  private _fixedPositionable;
+  private _dropdownEl;
   private _menuItems;
   private _trigger;
   static ɵfac: i0.ɵɵFactoryDeclaration<MoreMenuComponent, never>;
@@ -834,7 +883,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<"sm" | "default">;
+  readonly size: import("@angular/core").InputSignal<"default" | "sm">;
   readonly _disabledInput: import("@angular/core").InputSignal<boolean>;
   private readonly _cvaDisabled;
   protected readonly disabled: import("@angular/core").Signal<boolean>;
@@ -1372,6 +1421,11 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
   protected onSort(field: string): void;
   protected onPageChange(p: number): void;
   protected onTabChange(value: string): void;
+  /**
+   * Wire name of a column's filter: `filterParam` when set, else the column `key`. Used ONLY for the column-filter query
+   * param, the /filter-counts lookup, `_colFilterValues` and saved views (never for sort, row data, bulk fields).
+   */
+  protected _filterName(col: ColumnDef): string;
   protected onColFilterChange(column: string, values: string[]): void;
   protected clearFilters(): void;
   protected getColFilter(col: ColumnDef): {
@@ -1685,7 +1739,7 @@ export declare class ModalComponent implements OnInit, OnDestroy {
   readonly title: import("@angular/core").InputSignal<string>;
   readonly description: import("@angular/core").InputSignal<string>;
   readonly maxWidth: import("@angular/core").InputSignal<string>;
-  readonly bodyOverflow: import("@angular/core").InputSignal<"auto" | "visible" | "hidden">;
+  readonly bodyOverflow: import("@angular/core").InputSignal<"hidden" | "auto" | "visible">;
   readonly close: import("@angular/core").OutputEmitterRef<void>;
   protected readonly titleId: string;
   private readonly el;
@@ -1843,7 +1897,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<"auto" | "none" | "metadata">;
+  readonly preload: import("@angular/core").InputSignal<"none" | "auto" | "metadata">;
   /** 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>;
@@ -1908,7 +1962,7 @@ export declare class TooltipDirective {
   /** Tooltip text; empty or null disables the tooltip. */
   readonly uiTooltip: import("@angular/core").InputSignal<string | null | undefined>;
   /** Preferred side; flips to the other side when there is no room. */
-  readonly tooltipPosition: import("@angular/core").InputSignal<"top" | "bottom">;
+  readonly tooltipPosition: import("@angular/core").InputSignal<"bottom" | "top">;
   private readonly host;
   private readonly doc;
   private bubble;
@@ -2111,7 +2165,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" | "xs" | "lg">;
-  readonly type: import("@angular/core").InputSignal<"button" | "reset" | "submit">;
+  readonly type: import("@angular/core").InputSignal<"reset" | "submit" | "button">;
   readonly disabled: import("@angular/core").InputSignal<boolean>;
   readonly loading: import("@angular/core").InputSignal<boolean>;
   readonly fullWidth: import("@angular/core").InputSignal<boolean>;
@@ -2548,6 +2602,8 @@ export interface TemplateItem {
   subject: string | null;
   body: string;
   isActive?: boolean;
+  /** Set when the API says whether this is a built-in system template (true) or one the company wrote (false); drives the System / Custom badge. Absent = no badge. */
+  isSystem?: boolean;
   activeFrom?: string | null;
   activeTo?: string | null;
   useAllYear?: boolean;
@@ -2906,10 +2962,268 @@ export declare class ComboboxComponent<T = unknown> implements ControlValueAcces
     "blurred": "blurred";
   }, never, never, true, never>;
 }
+export interface RadioOption {
+  value: string;
+  label: string;
+  description?: string;
+  disabled?: boolean;
+}
+/**
+ * Group of native radio buttons inside a `<fieldset>` (+ `<legend>` = `label`), a ControlValueAccessor (string value, `''`
+ * = nothing selected). Arrow keys move and select natively because all radios share one `name`.
+ * Built-in validation: `required` -> "<label> is required."; a non-empty value that is not one of the `options` ->
+ * "Select a valid option." (not checked while `options` is empty). Disabled groups are never invalid.
+ *
+ * Validity API (same on every ui input): Angular `Validator`, signals `invalid` + `errorMessage`, `invalidChange` output,
+ * provides `UiFieldValidity`. Messages show after the group lost focus or while `[showErrors]="true"`; a host `[error]` wins.
+ */
+export declare class RadioGroupComponent implements ControlValueAccessor, Validator, UiFieldValidity {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly options: import("@angular/core").InputSignal<RadioOption[]>;
+  readonly required: import("@angular/core").InputSignal<boolean>;
+  readonly hint: import("@angular/core").InputSignal<string>;
+  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 orientation: import("@angular/core").InputSignal<"vertical" | "horizontal">;
+  /** Native `name` shared by the radios; a unique one is generated when omitted. */
+  readonly name: import("@angular/core").InputSignal<string>;
+  protected readonly _disabledInput: import("@angular/core").InputSignal<boolean>;
+  private readonly _cvaDisabled;
+  protected readonly disabled: import("@angular/core").Signal<boolean>;
+  private readonly _generatedName;
+  protected get _name(): string;
+  protected readonly _descId: string;
+  protected readonly _value: import("@angular/core").WritableSignal<string>;
+  private readonly _reveal;
+  private readonly _issue;
+  /** True while the value 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 ('' when valid), shown or not. */
+  readonly errorMessage: import("@angular/core").Signal<string>;
+  /** Emits whenever the field becomes invalid / valid. */
+  readonly invalidChange: import("@angular/core").OutputEmitterRef<boolean>;
+  protected readonly _activeError: import("@angular/core").Signal<string>;
+  private _onValidatorChange;
+  constructor();
+  /** Re-run the form control's validation when a rule input (required, options) changes. */
+  ngOnChanges(): void;
+  validate(control: AbstractControl): ValidationErrors | null;
+  registerOnValidatorChange(fn: () => void): void;
+  private _onChange;
+  private _onTouched;
+  writeValue(val: string): void;
+  registerOnChange(fn: (v: string) => void): void;
+  registerOnTouched(fn: () => void): void;
+  setDisabledState(d: boolean): void;
+  protected onSelect(value: string): void;
+  /** Touched once focus leaves the whole group (moving between its radios does not count). */
+  protected onFocusOut(event: FocusEvent): void;
+  private _check;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "ui-radio-group", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "required": {
+      "alias": "required";
+      "required": false;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "error": {
+      "alias": "error";
+      "required": false;
+      "isSignal": true;
+    };
+    "showErrors": {
+      "alias": "showErrors";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "_disabledInput": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "invalidChange": "invalidChange";
+  }, never, never, true, never>;
+}
+/**
+ * Types and pure helpers for the signer side of sending documents (docs/send-documents-contract.md, Addendum 2026-10-19).
+ * Everything here is app-agnostic: the roles are `signer1 .. signer4`, labels / names come from the host.
+ */
+/** A CUSTOMER signer role. The countersigner (the sending user) is never a role: it is the document's own setting. */
+export type SignerRole = 'signer1' | 'signer2' | 'signer3' | 'signer4';
+/** All roles, in signing order (the order is strictly sequential by role number). */
+export declare const SIGNER_ROLES: readonly SignerRole[];
+/** The part of a document the host's `resolveRoles` callback is called with. */
+export interface DocumentRolesTarget {
+  id: string;
+  title: string;
+  fileName: string | null;
+}
+/**
+ * Turns the signer section on (`documentSigners` of `ui-send-message-panel`). `null` / not passed = the panel is the plain single-recipient
+ * panel and nothing about signers is shown or sent.
+ */
+export interface DocumentSignersConfig {
+  /** Largest number of customer signers the panel accepts (roles above it are ignored). Default 4. */
+  maxSigners?: number;
+  /** Labels per role. Default `Signer 1` .. `Signer 4`. */
+  roleLabels?: Partial<Record<SignerRole, string>>;
+  /** May one person fill two roles? Default false. */
+  allowSameContactInRoles?: boolean;
+  /** Must every further signer have an email address (the chain emails each signer)? Default true; `false` only lets Send through with a warning-free row (the server then decides). */
+  requireSignerEmail?: boolean;
+  /** Name shown in the read-only countersign line ("Countersigned by <name> after all signers."). Default `you`. */
+  countersignerName?: string;
+  /**
+   * Reads the customer roles a document defines when its `GET /documents` row has no `signerRoles` key (an app that keeps its
+   * placements elsewhere). Called once per chosen document, and again on "Retry". A failure blocks Send and offers a retry. An empty
+   * list = the document has no signature fields (informational).
+   */
+  resolveRoles?: (doc: DocumentRolesTarget) => Observable<SignerRole[]>;
+}
+/** One entry of `documents.signers` (present only for a document with MORE THAN ONE customer signer, always complete). */
+export interface SendSigner {
+  role: SignerRole;
+  contactId: string;
+  name: string;
+  email: string | null;
+  /** 1..N, equal to the role number (strictly sequential). */
+  order: number;
+}
+/** Values the host has for THIS send, keyed by the keys it declares in `documentContextTypes` (e.g. `{ propertyId: '…' }`). */
+export type SendContext = Record<string, string>;
+/** One context key the app's backend accepts. */
+export interface ContextTypeDef {
+  key: string;
+  label: string;
+}
+/** What `documentMergeCheck` sends (default route `POST <baseUrl>/documents/merge-check`). */
+export interface MergeCheckRequest {
+  documentIds: string[];
+  customerId?: string;
+  signers?: SendSigner[];
+  context?: SendContext;
+}
+/** One data field that would be left empty. */
+export interface MergeCheckEmptyField {
+  key: string;
+  label: string;
+  page?: number;
+  /** `NO_CONTEXT` | `NO_DATA` | `UNKNOWN_PATH` (other values are shown generically). */
+  reason?: string;
+  /** Optional plain-language reason from the server ("no property selected"); wins over the generic text of `reason`. */
+  detail?: string;
+}
+export interface MergeCheckResult {
+  documents: {
+    documentId: string;
+    title?: string;
+    empty: MergeCheckEmptyField[];
+  }[];
+}
+/** A host function that runs the merge check itself (instead of the default route). */
+export type MergeCheckFn = (req: MergeCheckRequest) => Observable<MergeCheckResult>;
+/** The structural part of a chosen document the helpers below read. */
+export interface SignerDocLike {
+  id: string;
+  title: string;
+  requiresCountersign?: boolean;
+  signerRoles?: SignerRole[];
+  hasMapping?: boolean;
+  hasDataFields?: boolean;
+}
+/** Where the roles of a document without a `signerRoles` key stand when the host resolves them. */
+export interface RoleState {
+  status: 'loading' | 'ready' | 'error';
+  roles: SignerRole[];
+}
+/** What the signer logic concluded for the chosen documents (only on the value when `documentSigners` is on). */
+export interface DocumentSignerInfo {
+  /** `ready` once every document's roles are known; `loading` / `error` block Send. */
+  status: 'loading' | 'ready' | 'error';
+  /** Every chosen document has no signature fields: the send is informational (view-only). */
+  informational: boolean;
+  /** Customer roles of the ONE chosen document (always starting at signer1, no gaps). Empty for several documents / informational. */
+  roles: SignerRole[];
+  /** Exactly one document, with more than one customer signer. */
+  multiSigner: boolean;
+  /** A document that is sent for signing requires the sender's countersignature. */
+  countersign: boolean;
+  /** Several documents are chosen and one of them has several signers (it still goes to the one recipient). */
+  multiDocumentNote: boolean;
+  /** Under the document chip: what the mapping covers ('' when unknown). */
+  fieldsLine: string;
+}
+export declare const SIGNER_ROLE_LABEL_DEFAULT: (role: SignerRole) => string;
+export declare function roleNumber(role: SignerRole): number;
+/** The label of a role: the host's `roleLabels` entry, else `Signer N`. */
+export declare function signerRoleLabel(role: SignerRole, cfg?: DocumentSignersConfig | null): string;
+/** Valid roles only (`signer1..N`, N ≤ maxSigners), unique, sorted. Anything else is dropped. */
+export declare function normalizeRoles(raw: unknown, maxSigners?: number): SignerRole[];
+/**
+ * The customer roles a send needs from a document's saved roles: signer1 is always the recipient, and the roles run without gaps up to
+ * the highest saved one (a partial list is never sent). `[]` stays `[]` (no signature fields).
+ */
+export declare function effectiveRoles(saved: SignerRole[]): SignerRole[];
+/** True when the document has mapped data fields (the pre-send "fields that will be empty" check applies to it only). */
+export declare function hasMappedDataFields(doc: SignerDocLike): boolean;
+/** What the signer logic concludes for the chosen documents. `null` = `documentSigners` is off or nothing is chosen. */
+export declare function describeDocumentSigners(docs: SignerDocLike[], states: Record<string, RoleState>, cfg: DocumentSignersConfig | null | undefined): DocumentSignerInfo | null;
+/** The read-only countersign line ('' = not shown). */
+export declare function countersignLine(info: DocumentSignerInfo | null, cfg: DocumentSignersConfig | null | undefined, viaDocuSign: boolean): string;
+export interface SignerPick {
+  id: string;
+  name: string;
+  email?: string | null;
+}
+/** The complete `signers` list (recipient first), or null while any role has no contact. */
+export declare function buildSigners(roles: SignerRole[], recipient: SignerPick, picks: Partial<Record<SignerRole, SignerPick | null>>): SendSigner[] | null;
+/**
+ * The first problem per role (`''` = fine) in signing order: empty → `<Role label> is required.`, no email → `<Name> has no email address.`,
+ * the same person twice (unless allowed) → `<Name> is already <Earlier role label>.` on the later row.
+ */
+export declare function signerProblems(roles: SignerRole[], recipient: SignerPick, picks: Partial<Record<SignerRole, SignerPick | null>>, cfg: DocumentSignersConfig | null | undefined): Partial<Record<SignerRole, string>>;
+/** Only the declared context keys, with non-blank values; `undefined` when nothing is left. */
+export declare function forwardContext(ctx: SendContext | null | undefined, types: readonly ContextTypeDef[]): {
+  context?: SendContext;
+  dropped: string[];
+};
+/** One merge-check field as text: `Property Address (no property selected)`. */
+export declare function mergeFieldText(f: MergeCheckEmptyField): string;
+/** The warning lines of a merge-check answer: one line for one document, `<title>: …` per document for several. Nothing when nothing is empty. */
+export declare function mergeWarningLines(res: MergeCheckResult | null | undefined, docTitles: Record<string, string>): string[];
 /** What the sender wants done with the chosen documents. Same values as the backend (`ESIGN` | `ATTACH` | `BOTH`). */
 export type DocumentSendPurpose = 'ESIGN' | 'ATTACH' | 'BOTH';
 /** How the request reaches the recipient — derived from the channel: the Email tab sends `EMAIL`, the Text tab `TEXT`. */
 export type DocumentSendDelivery = 'EMAIL' | 'TEXT';
+/** Who sends a signature request: the app's own e-signature (`NATIVE`) or DocuSign. */
+export type DocumentSignatureProvider = 'NATIVE' | 'DOCUSIGN';
 /** One document from `GET <baseUrl>/documents`, reduced to what the picker needs. */
 export interface DocumentOption {
   id: string;
@@ -2917,13 +3231,104 @@ export interface DocumentOption {
   fileName: string | null;
   /** True when the document has a stored file (so it can be attached to an email). */
   hasFile: boolean;
+  /** Only present (and true) when the row says the document needs the sender's countersignature (`requiresCountersign` on the `GET /documents` row): then a DocuSign send offers "Require my countersignature after client signs". */
+  requiresCountersign?: boolean;
+  /** Only with `documentSigners`: the document's customer roles from the `GET /documents` row (`signerRoles`). `[]` = no signature fields (informational). */
+  signerRoles?: SignerRole[];
+  /** The row says the document has saved placements of any kind (drives the "Fields placed for N signers" line and the merge check). */
+  hasMapping?: boolean;
+  /** The row says the document has mapped DATA fields (the pre-send merge check applies to it); when absent, `hasMapping` stands in. */
+  hasDataFields?: boolean;
+  /** Only for an envelope's document (`DocumentSeed.status`). */
+  status?: string;
+}
+/** A document the form starts with (`initialDocuments`). `hasFile` defaults to true. */
+export interface DocumentSeed {
+  id: string;
+  title: string;
+  fileName?: string | null;
+  hasFile?: boolean;
+  requiresCountersign?: boolean;
+  signerRoles?: SignerRole[];
+  hasMapping?: boolean;
+  hasDataFields?: boolean;
+  /** An envelope's document that is not `ACTIVE` (e.g. `ARCHIVED`) blocks the send: "<title> is archived, so this envelope can't be sent. …". */
+  status?: string;
+}
+/**
+ * An existing envelope the panel sends (`documentEnvelope`): its documents are fixed (no search, no remove) and the request is sent, not
+ * created. Give `documents` when the host has read them already, or `loadDocuments` to let the panel read them (it shows the wait, and a
+ * failure blocks Send with a Retry button). With neither, the envelope has no documents and cannot be sent.
+ */
+export interface DocumentEnvelopeTarget {
+  id: string;
+  /** Shown in the subject suggestion ("Signature required: <name>") and in the success toast. */
+  name: string;
+  documents?: DocumentSeed[];
+  loadDocuments?: () => Observable<DocumentSeed[]>;
+}
+/** The document a host's `documentPreview` handler is called with. */
+export interface DocumentPreviewTarget {
+  id: string;
+  title: string;
+  fileName: string | null;
+}
+/** Opens a document for preview (the host knows its own route / viewer). Called synchronously inside the click. */
+export type DocumentPreviewHandler = (doc: DocumentPreviewTarget) => void;
+/**
+ * Turns on the "Expiry and Reminders" settings of the document section and sets their starting values (the keys you leave out start at
+ * the defaults below). `null` / not passed = the settings are not shown and nothing about them is sent.
+ */
+export interface DocumentSigningOptions {
+  /** Days until an unsigned request expires: whole number 1-90 (default 7). */
+  expiryDays?: number;
+  /** Days between reminders: whole number 1-30 (default 2). */
+  reminderIntervalDays?: number;
+  /** How many reminders at most: whole number 0-10 (default 3). */
+  maxReminders?: number;
 }
+/** Defaults and limits of the signing settings (the same limits the servers enforce). */
+export declare const DEFAULT_SIGNING_OPTIONS: {
+  readonly expiryDays: 7;
+  readonly reminderIntervalDays: 2;
+  readonly maxReminders: 3;
+};
+export declare const SIGNING_LIMITS: {
+  readonly expiryDays: {
+    readonly min: 1;
+    readonly max: 90;
+    readonly label: "Expiry (days)";
+  };
+  readonly reminderIntervalDays: {
+    readonly min: 1;
+    readonly max: 30;
+    readonly label: "Reminder Interval (days)";
+  };
+  readonly maxReminders: {
+    readonly min: 0;
+    readonly max: 10;
+    readonly label: "Max Reminders";
+  };
+};
+export declare const DOCUMENT_PROVIDER_OPTIONS: RadioOption[];
 /** The value `ui-document-send-options` emits and the message forms turn into `SendEmailPayload.documents` / `SendTextPayload.documents`. */
 export interface DocumentSendValue {
   documentIds: string[];
   documents: DocumentOption[];
   purpose: DocumentSendPurpose;
   delivery: DocumentSendDelivery;
+  /** Only when the signing settings are shown (host `signing` input), valid and the request is a native e-signature one. */
+  expiryDays?: number;
+  reminderIntervalDays?: number;
+  maxReminders?: number;
+  /** Only when the provider choice is offered (`docuSignConnected` and exactly one document on the email channel). */
+  provider?: DocumentSignatureProvider;
+  /** Only with `provider: 'DOCUSIGN'`. */
+  docuSign?: {
+    countersign: boolean;
+  };
+  /** Only when `signers` (the host's `documentSigners`) is on and a document is chosen: what the signer logic concluded. Never part of the payload. */
+  signerInfo?: DocumentSignerInfo;
 }
 export declare const DOCUMENT_PURPOSE_OPTIONS: SelectOption[];
 /**
@@ -2934,6 +3339,16 @@ export declare const DOCUMENT_PURPOSE_OPTIONS: SelectOption[];
  * "What should the recipient do?" select (e-signature / attachment / both). On the text channel documents can only go as a
  * link, so the purpose is fixed to e-signature and the select is not shown.
  *
+ * Optional parts, all off by default (hosts reach them through the same-named inputs of `ui-send-message-panel`):
+ *  - `signing` — "Expiry and Reminders" (expiry days, reminder interval, max reminders) for native e-signature requests;
+ *  - `docuSignConnected` — "Native E-Sign / Send via DocuSign" choice (email channel, exactly one document);
+ *  - `documentPreview` — "Preview Document" button(s) that call the host's handler.
+ *  - `signers` — the signer logic of the panel's `documentSigners` (a document's customer roles, informational documents, the
+ *    one-signer DocuSign rule, the document's own countersign setting); the value then carries `signerInfo`;
+ *  - `envelope` — an existing envelope: its documents are the fixed list (given, or read through `loadDocuments`).
+ *
+ * The signing settings are ONE collapsed summary line ("Signing options: expires in 7 days, ...") with a Change / Hide button.
+ *
  * It is embedded by `ui-send-message-panel` (`[documents]="true"`); it can also be used on its own.
  *
  * ```html
@@ -2941,7 +3356,8 @@ export declare const DOCUMENT_PURPOSE_OPTIONS: SelectOption[];
  * ```
  *
  * Validity: provides `UiFieldValidity` (`invalid` / `errorMessage`) and the `invalidChange` output. Invalid when `required`
- * and nothing is chosen, or when the purpose is "Send as attachment" and a chosen document has no stored file. Messages
+ * and nothing is chosen, when the purpose is "Send as attachment" and a chosen document has no stored file, or when a shown signing
+ * setting is blank / out of range. Messages
  * show only while `showErrors` is true.
  */
 export declare class DocumentSendOptionsComponent implements UiFieldValidity {
@@ -2968,18 +3384,58 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
    * of the value straight away; the user can remove them or add more. Read once — later changes to the input are ignored.
    * `hasFile` defaults to true (an attachment check then relies on the server's answer).
    */
-  readonly initialDocuments: import("@angular/core").InputSignal<{
-    id: string;
-    title: string;
-    fileName?: string | null;
-    hasFile?: boolean;
-  }[]>;
+  readonly initialDocuments: import("@angular/core").InputSignal<DocumentSeed[]>;
+  /**
+   * Shows the "Expiry and Reminders" settings (Expiry 1-90 days, Reminder Interval 1-30 days, Max Reminders 0-10, all required whole
+   * numbers; starting at 7 / 2 / 3 unless this object says otherwise) while at least one document is chosen and the request is a native
+   * e-signature one (purpose e-signature or both; always on the text channel). `null` (default) = not shown, nothing sent. Read once.
+   */
+  readonly signing: import("@angular/core").InputSignal<DocumentSigningOptions | null | undefined>;
+  /**
+   * The host knows whether DocuSign is connected (the library never calls `/docusign/status`). `true` offers "Native E-Sign / Send via
+   * DocuSign" on the email channel while exactly one document is chosen; `false` (default) = no choice, native only.
+   */
+  readonly docuSignConnected: import("@angular/core").InputSignal<boolean>;
+  /**
+   * "Preview Document": called with the document when its button is clicked (one button for one document, one per document for several).
+   * `null` (default) hides the buttons. The host opens its own viewer; to open a new tab do it synchronously inside this call
+   * (`window.open` after an await is blocked as a popup in Safari).
+   */
+  readonly documentPreview: import("@angular/core").InputSignal<DocumentPreviewHandler | null>;
+  /**
+   * Turns on the signer logic (`documentSigners` of the panel): a document's customer roles (from its row's `signerRoles`, or the config's
+   * `resolveRoles`), informational documents (no signature fields), the one-signer DocuSign rule and the read-only countersign rule.
+   * The value then carries `signerInfo`. `null` (default) = none of it; nothing changes.
+   */
+  readonly signers: import("@angular/core").InputSignal<DocumentSignersConfig | null | undefined>;
+  /**
+   * An existing envelope (`documentEnvelope` of the panel): its documents are the list, fixed (no search, no remove buttons). Read when it
+   * is set; `null` (default) = the sender chooses the documents.
+   */
+  readonly envelope: import("@angular/core").InputSignal<DocumentEnvelopeTarget | null>;
+  /** The document list is fixed: an existing envelope's. */
+  readonly locked: import("@angular/core").Signal<boolean>;
   protected readonly purposeOptions: import("@angular/core").Signal<SelectOption[]>;
   readonly search$: Subject<string>;
   readonly options: import("@angular/core").WritableSignal<ComboboxOption<DocumentOption>[]>;
   readonly loading: import("@angular/core").WritableSignal<boolean>;
   readonly selected: import("@angular/core").WritableSignal<DocumentOption[]>;
   readonly purposeChoice: import("@angular/core").WritableSignal<DocumentSendPurpose>;
+  /** What the sender picked in the provider choice (only effective while the choice is offered). */
+  readonly providerChoice: import("@angular/core").WritableSignal<DocumentSignatureProvider>;
+  readonly countersignChoice: import("@angular/core").WritableSignal<boolean>;
+  /** Roles of documents whose row had no `signerRoles` and that the host resolves (`signers().resolveRoles`). */
+  readonly roleStates: import("@angular/core").WritableSignal<Record<string, RoleState>>;
+  /** The envelope's documents: `loading` / `error` while the panel reads them (`loadDocuments`), `ready` once known. */
+  readonly envelopeStatus: import("@angular/core").WritableSignal<"error" | "loading" | "ready" | "idle">;
+  private envelopeSub;
+  private readonly roleSubs;
+  /** The sender opened the collapsed "Signing options" line. */
+  readonly signingOpen: import("@angular/core").WritableSignal<boolean>;
+  readonly expiryDays: import("@angular/core").WritableSignal<string>;
+  readonly reminderIntervalDays: import("@angular/core").WritableSignal<string>;
+  readonly maxReminders: import("@angular/core").WritableSignal<string>;
+  protected readonly providerOptions: RadioOption[];
   /** The search box; cleared (and kept focused) after each pick so the next search starts empty. */
   private readonly combo;
   /** True when the last search request failed (shown inline instead of "No matching documents"). */
@@ -2991,15 +3447,59 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
    * `ESIGN` has nothing to offer there. The section then shows a short note instead of a picker (it never silently sends another purpose).
    */
   readonly available: import("@angular/core").Signal<boolean>;
-  /** The purpose that is actually sent: the text channel can only send a link, so it is always e-signature. */
+  /** True when the sender can choose DocuSign: the host says it is connected, email channel, exactly one document (DocuSign sends one), and e-signature is a supported purpose. */
+  readonly providerChoiceShown: import("@angular/core").Signal<boolean>;
+  /** The provider that is actually used: DocuSign only while the choice is offered. */
+  readonly provider: import("@angular/core").Signal<DocumentSignatureProvider>;
+  /** The countersignature checkbox: a DocuSign send of a document flagged `requiresCountersign`. */
+  readonly showCountersign: import("@angular/core").Signal<boolean>;
+  /** The checkbox (no `signers`) or, with `signers` on, the document's own setting: the document says whether it is countersigned. */
+  readonly countersign: import("@angular/core").Signal<boolean>;
+  /** The signing settings are shown: turned on by the host, a document is chosen, and it is a native e-signature request (not attachment only, not DocuSign). */
+  readonly signingVisible: import("@angular/core").Signal<boolean>;
+  /** What the signer logic concluded for the chosen documents (`null` when `signers` is off or nothing is chosen). */
+  readonly signerInfo: import("@angular/core").Signal<DocumentSignerInfo | null>;
+  /** Why an envelope cannot be sent ('' = it can): nothing to send, or a document that is no longer active. Shown under the section. */
+  readonly envelopeProblem: import("@angular/core").Signal<string>;
+  /** Why Send waits for the envelope's documents ('' when they are known). */
+  readonly envelopeReadMessage: import("@angular/core").Signal<"" | "Reading the envelope's documents…" | "The documents of this envelope couldn't be read, so it can't be sent yet.">;
+  /** Why Send waits for the document's signers ('' when they are known). */
+  readonly signerReadMessage: import("@angular/core").Signal<"" | "Reading the document's signers…" | "The signers of this document couldn't be read, so it can't be sent yet.">;
+  /** The collapsed line: "Signing options: expires in 7 days, reminders every 2 days, up to 3". */
+  readonly signingSummary: import("@angular/core").Signal<string>;
+  /** Open when the sender opened it, or while a value is broken (the error must be visible). */
+  readonly signingExpanded: import("@angular/core").Signal<boolean>;
+  /** The purpose that is actually sent: the text channel and DocuSign can only do e-signature. */
   readonly purpose: import("@angular/core").Signal<DocumentSendPurpose>;
   readonly delivery: import("@angular/core").Signal<DocumentSendDelivery>;
   readonly value: import("@angular/core").Signal<DocumentSendValue>;
-  /** The first broken rule ('' when valid). */
+  /** The first broken signing setting ('' when fine or not shown) — the inputs show their own messages. */
+  readonly signingError: import("@angular/core").Signal<string>;
+  /** The first broken document rule ('' when fine) — shown under the section. */
+  readonly documentError: import("@angular/core").Signal<string>;
+  /** The first broken rule ('' when valid): the document rules, the wait for the signers, then the signing settings. */
   readonly errorMessage: import("@angular/core").Signal<string>;
   readonly invalid: import("@angular/core").Signal<boolean>;
   constructor();
+  private static seedToOption;
+  /** Sets the envelope's documents as the list; reads them first when the host gave a loader. */
+  private loadEnvelope;
+  /** "Retry" after the envelope's documents could not be read. */
+  retryEnvelope(): void;
   private static toOption;
+  /** Asks the host for the roles of every chosen document that needs it; forgets documents that were removed. */
+  private syncRoleRequests;
+  private requestRoles;
+  /** "Retry" after the roles of a document could not be read. */
+  retryRoles(): void;
+  /** The Change / Hide button: it flips what the sender sees (a line kept open by an error stays open, but a later fix lets it close). */
+  toggleSigning(): void;
+  private seedSigning;
+  /** `ui-text-input` hands the typed text back as a string (or a number from a programmatic write). */
+  protected asText(v: unknown): string;
+  setProvider(p: string): void;
+  /** Calls the host's preview handler straight from the click (no await in between: Safari blocks a tab opened later). */
+  preview(doc: DocumentOption): void;
   onPick(opt: ComboboxOption<DocumentOption> | null): void;
   remove(id: string): void;
   setPurpose(p: string): void;
@@ -3037,11 +3537,84 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
       "required": false;
       "isSignal": true;
     };
+    "signing": {
+      "alias": "signing";
+      "required": false;
+      "isSignal": true;
+    };
+    "docuSignConnected": {
+      "alias": "docuSignConnected";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentPreview": {
+      "alias": "documentPreview";
+      "required": false;
+      "isSignal": true;
+    };
+    "signers": {
+      "alias": "signers";
+      "required": false;
+      "isSignal": true;
+    };
+    "envelope": {
+      "alias": "envelope";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "valueChange": "valueChange";
     "invalidChange": "invalidChange";
   }, never, never, true, never>;
 }
+/**
+ * Video share-link helpers shared by every app (they replace the apps' own copies, e.g. real-estate `video-link.utils.ts`).
+ *
+ * The share link of a video (`VideoMessage.shareLink`) carries the playback settings as query parameters:
+ *   autoplay=1 · ref=<contact id> · ctaType · ctaUrl · ctaLabel · hideReactions=1   (in exactly that order).
+ */
+interface VideoLinkOptions {
+  autoplay?: boolean;
+  /** The recipient: lets the video page track who watched (`ref`). */
+  contactId?: string;
+  /** '' / undefined = none (the video's own default); `schedule` | `contact` | `custom`. */
+  ctaType?: string;
+  ctaUrl?: string;
+  ctaLabel?: string;
+  hideReactions?: boolean;
+}
+/**
+ * Default video settings the host reads from its Communication settings (same keys as `/comm-settings` without the `videoDefault`
+ * prefix): `videoDefaultAutoplay` → `autoplay`, `videoDefaultCtaType` → `ctaType`, … Missing keys mean "off" / "none".
+ */
+interface VideoDefaults {
+  autoplay?: boolean;
+  ctaType?: string;
+  ctaUrl?: string;
+  ctaLabel?: string;
+  hideReactions?: boolean;
+}
+/** `baseLink` + the settings as query parameters (unchanged when no setting is on). A base that already has a query gets `&`. */
+export declare function buildVideoLink(baseLink: string, options?: VideoLinkOptions): string;
+/**
+ * The share link of a freshly attached video: `baseLink` with the host's defaults and the recipient applied — exactly the link
+ * `ui-video-link-settings` shows before the sender changes anything.
+ */
+declare function videoLinkWithDefaults(baseLink: string, defaults?: VideoDefaults, contactId?: string): string;
+/** Strips any "🎬 Watch video: <url>" line previously inserted into a message body (the line format the apps' own composers use). */
+export declare function stripVideoLink(text: string): string;
+/** Appends a "🎬 Watch video: <link>" line to a message body (replacing one that is already there). */
+export declare function appendVideoLink(text: string, link: string): string;
+/** The line `ui-send-message-panel` puts in the message for an attached video: `Watch "<title>": <link>`. */
+export declare function videoMessageLine(title: string, link: string): string;
+/**
+ * Puts `next` into `body` in place of `prev` (the line inserted earlier), so changing a video setting rewrites the link without
+ * touching the rest of the message:
+ *  - no `prev` yet → appended after a blank line (no separator for an empty body);
+ *  - `prev` is in the body → replaced in place; with an empty `next` it is removed together with its separator;
+ *  - `prev` was edited away by the sender → the body is left as the sender wrote it.
+ */
+export declare function applyVideoLine(body: string, prev: string, next: string): string;
 /** The `documents` key of `SendEmailPayload` / `SendTextPayload`: present only when at least one document was chosen. */
 interface SendDocumentsPayload {
   documentIds: string[];
@@ -3049,7 +3622,54 @@ interface SendDocumentsPayload {
   purpose: DocumentSendPurpose;
   /** `EMAIL` for the email form, `TEXT` for the text form. */
   delivery: DocumentSendDelivery;
+  /** Only when the host turned on `documentSigningOptions` and the request is a native e-signature request (purpose `ESIGN` / `BOTH`): days until the request expires (1-90). */
+  expiryDays?: number;
+  /** Same condition as `expiryDays`: days between reminders (1-30). */
+  reminderIntervalDays?: number;
+  /** Same condition as `expiryDays`: how many reminders at most (0-10). */
+  maxReminders?: number;
+  /** Only when the host passed `docuSignConnected` and the sender can choose (email, exactly one document): which e-signature provider sends the request. */
+  provider?: DocumentSignatureProvider;
+  /** Only with `provider: 'DOCUSIGN'`: `countersign` is true when the sender ticked "Require my countersignature after client signs" (only offered for a document flagged `requiresCountersign`). */
+  docuSign?: {
+    countersign: boolean;
+  };
+  /**
+   * Only when the host turned on `documentSigners`, the request is a native e-signature one, ONE document is chosen and it has MORE THAN ONE
+   * customer signer: all N signers including signer1 (= the recipient), ordered by role, never partial. A single-signer send has no such key.
+   */
+  signers?: SendSigner[];
+  /** Only when the host passed `sendContext` and at least one key it declared in `documentContextTypes` has a value (other keys are dropped). */
+  context?: SendContext;
+  /** Only when the send is of an existing envelope (`documentEnvelope`): its id; the request is not created again, it is sent. */
+  envelopeId?: string;
+  /** Only with `documentSigners` on, when every chosen document has no signature fields: the send is informational (the recipient gets a view link, nothing is signed). */
+  informational?: true;
+}
+/** What the success toast of a document send can say (`documentSentMessage` of the panel). */
+interface DocumentSentInfo {
+  titles: string[];
+  /** Only when an existing envelope was sent (`documentEnvelope`). */
+  envelopeName?: string;
+  channel: 'email' | 'text';
+  provider?: DocumentSignatureProvider;
+  /** Every chosen document has no signature fields (a view link was sent). */
+  informational: boolean;
+}
+/** Builds the success toast of a document send (default: `Email sent` / `Text message sent` / `"<title>" sent via DocuSign` / `Envelope "<name>" sent`). */
+type DocumentSentMessage = (info: DocumentSentInfo) => string;
+/** The optional parts the form adds to the `documents` payload besides what the document section holds. */
+interface DocumentsPayloadExtras {
+  signers?: SendSigner[] | null;
+  context?: SendContext;
+  envelopeId?: string;
 }
+/**
+ * The `documents` part of a payload from what the document section holds. The optional keys (signing settings, provider, DocuSign
+ * options) are present only when the section produced them, so a host that turned none of them on gets exactly
+ * `{ documentIds, purpose, delivery }`.
+ */
+declare function buildDocumentsPayload(v: DocumentSendValue, delivery: DocumentSendDelivery, purpose?: DocumentSendPurpose, extras?: DocumentsPayloadExtras): SendDocumentsPayload;
 /**
  * Subject of the signature request when the sender has none (texts have no subject). The server treats exactly this
  * text as a placeholder and builds the real subject from the document names.
@@ -3060,7 +3680,7 @@ export declare const DEFAULT_DOCUMENT_SUBJECT = "Document Signature Required";
  * sender leaves the subject out: signing (ESIGN / BOTH) → "Signature required: <title>" (several: "<N> documents to sign: <first>…");
  * attachment only → "Document attached: <title>" (several: "<N> documents attached: <first>…"). '' for no documents.
  */
-export declare function suggestDocumentSubject(titles: string[], purpose: DocumentSendPurpose): string;
+export declare function suggestDocumentSubject(titles: string[], purpose: DocumentSendPurpose, informational?: boolean): string;
 /** Most people that can be copied on one email (same limit as the server). */
 export declare const MAX_CC = 10;
 /** CC addresses typed as text: comma / semicolon / whitespace separated, trimmed, de-duplicated (case-insensitive). */
@@ -3079,7 +3699,38 @@ interface CreateDocumentRequestBody {
   purpose: DocumentSendPurpose;
   delivery: DocumentSendDelivery;
   ccEmails?: string[];
+  /** Native e-signature requests only, and only when the host turned on `documentSigningOptions`. */
+  expiryDays?: number;
+  reminderIntervalDays?: number;
+  maxReminders?: number;
+  /** Only with `documentSigners` and a document with several customer signers (complete, ordered). */
+  signers?: SendSigner[];
+  /** Only with `sendContext` / `documentContextTypes`. */
+  context?: SendContext;
+}
+/** The signing settings of a `documents` payload as optional keys of the create-request body (nothing when there are none). */
+declare function signingBodyFields(d: SendDocumentsPayload): Pick<CreateDocumentRequestBody, 'expiryDays' | 'reminderIntervalDays' | 'maxReminders'>;
+/** The body of `POST <baseUrl>/documents/envelopes/{id}/send` for an existing envelope: the create body without the document ids (the envelope already has them). */
+type ExistingEnvelopeSendBody = Omit<CreateDocumentRequestBody, 'documentIds'> & {
+  templateId?: string;
+};
+/**
+ * Sends an envelope that already exists (`documentEnvelope`): `POST <baseUrl>/documents/envelopes/{id}/send` with the recipient, message and
+ * options in the body (nothing is created first). The host can replace it with `[sendEmail]` / `[sendText]` (payload `documents.envelopeId`).
+ */
+export declare function sendExistingEnvelope(http: HttpClient, apiBase: string, envelopeId: string, body: ExistingEnvelopeSendBody): Observable<unknown>;
+/** The `signers` / `context` of a `documents` payload as optional keys of the create-request body (nothing when there are none). */
+declare function signersContextBodyFields(d: SendDocumentsPayload): Pick<CreateDocumentRequestBody, 'signers' | 'context'>;
+/** What the library sends to send ONE document through DocuSign (`POST <baseUrl>/docusign/send`). See docs/send-documents-contract.md. */
+interface DocuSignSendBody {
+  documentId: string;
+  contactId: string;
+  subject?: string;
+  message?: string;
+  countersignRequired: boolean;
 }
+/** The default DocuSign send: `POST <baseUrl>/docusign/send` → 200. The host can replace it with `[sendEmail]`. */
+declare function sendDocuSignRequest(http: HttpClient, apiBase: string, body: DocuSignSendBody): Observable<unknown>;
 /**
  * The default way a message form sends documents: create the request, then send it.
  *   1. POST <baseUrl>/documents/envelopes          → 201 { id, ... }
@@ -3152,19 +3803,45 @@ declare class SendEmailComponent implements OnInit {
   /** Purposes the app's backend supports for documents (default all); a single entry hides the purpose select. */
   readonly documentPurposes: import("@angular/core").InputSignal<DocumentSendPurpose[]>;
   /** Documents already chosen in the Documents section when the form opens. */
-  readonly initialDocuments: import("@angular/core").InputSignal<{
-    id: string;
-    title: string;
-    fileName?: string | null;
-    hasFile?: boolean;
-  }[]>;
+  readonly initialDocuments: import("@angular/core").InputSignal<DocumentSeed[]>;
+  /**
+   * Turns on the signer logic: one required contact per customer signer role of the chosen document, the read-only countersign line,
+   * informational documents (no signature fields) and the one-signer DocuSign rule. `null` (default) = the single recipient, unchanged.
+   */
+  readonly documentSigners: import("@angular/core").InputSignal<DocumentSignersConfig | null>;
+  /** Values the host has for THIS send; only the keys declared in `documentContextTypes` are sent, as `documents.context`. */
+  readonly sendContext: import("@angular/core").InputSignal<SendContext | null>;
+  /** The context keys the app's backend accepts. */
+  readonly documentContextTypes: import("@angular/core").InputSignal<ContextTypeDef[]>;
+  /** `true` = check (default route `POST <baseUrl>/documents/merge-check`), a function = the host's own check; shows a non-blocking "fields that will be empty" warning. */
+  readonly documentMergeCheck: import("@angular/core").InputSignal<boolean | MergeCheckFn>;
+  /** An existing envelope to send: its documents are fixed and it is sent (not created). Payload `documents.envelopeId`. `null` (default) = a new request from the chosen documents. */
+  readonly documentEnvelope: import("@angular/core").InputSignal<DocumentEnvelopeTarget | null>;
+  /** false = the app's email sending is switched off (Communication settings): Send stays off and the form says why. */
+  readonly emailEnabled: import("@angular/core").InputSignal<boolean>;
+  /** Builds the success toast of a document send (default texts otherwise). */
+  readonly documentSentMessage: import("@angular/core").InputSignal<DocumentSentMessage | null>;
   /** Shows a CC field; the typed addresses are sent as `cc`. Off = payload has no such key. */
   readonly showCc: import("@angular/core").InputSignal<boolean>;
+  /** Shows "Expiry and Reminders" for e-signature requests (see `DocumentSigningOptions`); sent as `documents.expiryDays` / `reminderIntervalDays` / `maxReminders`. `null` = off. */
+  readonly documentSigningOptions: import("@angular/core").InputSignal<DocumentSigningOptions | null | undefined>;
+  /** The host says DocuSign is connected: offers "Native E-Sign / Send via DocuSign" for a single document. Off = native only. */
+  readonly docuSignConnected: import("@angular/core").InputSignal<boolean>;
+  /** "Preview Document" button(s) in the Documents section call this; `null` hides them. */
+  readonly documentPreview: import("@angular/core").InputSignal<DocumentPreviewHandler | null>;
+  /**
+   * Turns on the video settings (Playback, Call-to-Action, Hide reactions, Watch Preview, Remove Video) once a video is attached, starting
+   * from these defaults, and makes the video link carry them. `null` (default) = the attached video's plain share link is inserted, as before.
+   */
+  readonly videoDefaults: import("@angular/core").InputSignal<VideoDefaults | null>;
   /** false hides Attach Files and "Schedule for later" (for a host whose send function can't deliver them). */
   readonly attachmentsAndScheduling: import("@angular/core").InputSignal<boolean>;
   readonly sent: import("@angular/core").OutputEmitterRef<void>;
   readonly emailAdded: import("@angular/core").OutputEmitterRef<string>;
   readonly validChange: import("@angular/core").OutputEmitterRef<boolean>;
+  /** A document send was refused because the document / envelope changed meanwhile (404 / 409): the host refreshes its list. */
+  readonly rejected: import("@angular/core").OutputEmitterRef<void>;
+  readonly EMAIL_DISABLED_MESSAGE = "Email sending is disabled, so this can't be sent. Enable it in Communication Settings.";
   mode: 'compose' | 'template';
   subject: string;
   body: string;
@@ -3192,6 +3869,11 @@ declare class SendEmailComponent implements OnInit {
   /** What the document section holds (null / empty = no documents) and whether it currently breaks a rule. */
   documentsValue: DocumentSendValue | null;
   documentsInvalid: boolean;
+  /** The complete signer list of the signer rows (null while a role has no contact) and whether they break a rule. */
+  signersValue: SendSigner[] | null;
+  signersInvalid: boolean;
+  /** Lines of the merge check ("These fields will be left empty: …"). */
+  mergeWarnings: string[];
   readonly savingEmail: import("@angular/core").WritableSignal<boolean>;
   readonly modeTabs: PillTab[];
   /** Market values (`area`, `median_price`, `dom`, `new_listings`) — only the ones `/service-areas` returned. */
@@ -3211,7 +3893,36 @@ declare class SendEmailComponent implements OnInit {
   get pendingEmailValid(): boolean;
   /** True when the sender chose at least one document (only possible when the `documents` input is on). */
   get hasDocuments(): boolean;
-  /** The people copied on the email, as typed (empty unless `showCc` is on). */
+  /** True when the sender chose to send the (single) document through DocuSign: DocuSign emails it itself, so CC, attachments and the required Subject / Message do not apply. */
+  get viaDocuSign(): boolean;
+  /** The recipient as Signer 1 (a stable object: it feeds a child input). */
+  readonly recipientPick: import("@angular/core").Signal<{
+    id: string;
+    name: string;
+    email: string;
+  }>;
+  /** The declared context keys with a value (`documents.context`); keys the app did not declare are dropped (with a development warning). */
+  readonly forwardedContext: import("@angular/core").Signal<SendContext | undefined>;
+  /** What the signer logic concluded for the chosen documents (null when `documentSigners` is off or nothing is chosen). */
+  get signerInfo(): DocumentSignerInfo | null;
+  /** The chosen documents the merge check looks at. */
+  get mergeDocuments(): DocumentOption[];
+  /** True when a native e-signature request for ONE document with several customer signers is being built: the signer rows are required. */
+  get signersActive(): boolean;
+  /** The signer section is shown: signer rows, and/or the countersign line (a signed document that is not just attached). */
+  get signersSectionShown(): boolean;
+  /** The signer rows restart whenever the chosen document changes. */
+  get signersKey(): string;
+  onSigners(v: SendSigner[] | null): void;
+  onSignersInvalid(bad: boolean): void;
+  onMergeWarnings(lines: string[]): void;
+  /** The lines of the ONE warning banner: what choosing a document removed, a multi-signer document among several, the merge check. */
+  get warningLines(): {
+    key: string;
+    text: string;
+    testId: string | null;
+  }[];
+  /** The people copied on the email, as typed (empty unless `showCc` is on, and not used by a DocuSign send). */
   get ccList(): string[];
   /** The first problem with the CC field ('' when fine). */
   get ccError(): string;
@@ -3279,6 +3990,20 @@ declare class SendEmailComponent implements OnInit {
   onFilesSelected(event: Event): void;
   removeAttachment(index: number): void;
   insertVideo(v: VideoMessage): void;
+  /** The body of the default DocuSign send: Subject / Message only when the sender has them (DocuSign has its own defaults otherwise). */
+  private docuSignBody;
+  /** The video attached through the settings flow (null = none) and the line it put into the message. */
+  videoPicked: VideoMessage | null;
+  /** Bumped to re-create the video picker (it keeps its own selection and has no clear output). */
+  videoPickerKey: number;
+  private _videoLine;
+  /** The picker's output: with `videoDefaults` the video gets its settings section, otherwise the plain link is inserted as before. */
+  onVideoSelected(v: VideoMessage): void;
+  /** The settings section's output: rewrites the video line of the message with the current link (the rest of the message is untouched). */
+  onVideoLink(link: string): void;
+  /** "Remove Video": takes the video line out of the message and brings the picker back. */
+  removeVideo(): void;
+  private discardVideo;
   submit(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<SendEmailComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SendEmailComponent, "ui-send-email", never, {
@@ -3352,12 +4077,67 @@ declare class SendEmailComponent implements OnInit {
       "required": false;
       "isSignal": true;
     };
-    "showCc": {
-      "alias": "showCc";
+    "documentSigners": {
+      "alias": "documentSigners";
       "required": false;
       "isSignal": true;
     };
-    "attachmentsAndScheduling": {
+    "sendContext": {
+      "alias": "sendContext";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentContextTypes": {
+      "alias": "documentContextTypes";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentMergeCheck": {
+      "alias": "documentMergeCheck";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentEnvelope": {
+      "alias": "documentEnvelope";
+      "required": false;
+      "isSignal": true;
+    };
+    "emailEnabled": {
+      "alias": "emailEnabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentSentMessage": {
+      "alias": "documentSentMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "showCc": {
+      "alias": "showCc";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentSigningOptions": {
+      "alias": "documentSigningOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "docuSignConnected": {
+      "alias": "docuSignConnected";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentPreview": {
+      "alias": "documentPreview";
+      "required": false;
+      "isSignal": true;
+    };
+    "videoDefaults": {
+      "alias": "videoDefaults";
+      "required": false;
+      "isSignal": true;
+    };
+    "attachmentsAndScheduling": {
       "alias": "attachmentsAndScheduling";
       "required": false;
       "isSignal": true;
@@ -3366,6 +4146,7 @@ declare class SendEmailComponent implements OnInit {
     "sent": "sent";
     "emailAdded": "emailAdded";
     "validChange": "validChange";
+    "rejected": "rejected";
   }, never, never, true, never>;
 }
 /** What the text form sends — the default `POST <baseUrl>/text-messages` body, or the host's `sendFn` argument. */
@@ -3406,6 +4187,8 @@ declare class SendTextComponent implements OnInit {
    * also marks a record Sent. Loading, toasts, `sent` and the double-send guard behave the same.
    */
   readonly sendFn: import("@angular/core").InputSignal<((payload: SendTextPayload) => Observable<unknown>) | null>;
+  /** Builds the success toast of a document send (default texts otherwise). */
+  readonly documentSentMessage: import("@angular/core").InputSignal<DocumentSentMessage | null>;
   /** Shows the "Documents" section (search your documents; they are texted as a link). Off = the form is unchanged. */
   readonly documents: import("@angular/core").InputSignal<boolean>;
   /** false hides Attach Image and "Schedule for later" (for a host whose send function can't deliver them). */
@@ -3413,15 +4196,35 @@ declare class SendTextComponent implements OnInit {
   /** Purposes the app's backend supports for documents (default all). The text form only sends `ESIGN`; without it the section is unavailable. */
   readonly documentPurposes: import("@angular/core").InputSignal<DocumentSendPurpose[]>;
   /** Documents already chosen in the Documents section when the form opens. */
-  readonly initialDocuments: import("@angular/core").InputSignal<{
-    id: string;
-    title: string;
-    fileName?: string | null;
-    hasFile?: boolean;
-  }[]>;
+  readonly initialDocuments: import("@angular/core").InputSignal<DocumentSeed[]>;
+  /**
+   * Turns on the signer logic for documents (informational documents, the multi-signer rule). A document with several customer signers
+   * can't be texted (the link goes to the first signer only): the section says "Send it by email." and Send stays off. `null` = unchanged.
+   */
+  readonly documentSigners: import("@angular/core").InputSignal<DocumentSignersConfig | null>;
+  /** Values the host has for THIS send; only the keys declared in `documentContextTypes` are sent, as `documents.context`. */
+  readonly sendContext: import("@angular/core").InputSignal<SendContext | null>;
+  /** The context keys the app's backend accepts. */
+  readonly documentContextTypes: import("@angular/core").InputSignal<ContextTypeDef[]>;
+  /** `true` = check (default route `POST <baseUrl>/documents/merge-check`), a function = the host's own check; shows a non-blocking "fields that will be empty" warning. */
+  readonly documentMergeCheck: import("@angular/core").InputSignal<boolean | MergeCheckFn>;
+  /** An existing envelope to text: its documents are fixed and it is sent (not created). Payload `documents.envelopeId`. */
+  readonly documentEnvelope: import("@angular/core").InputSignal<DocumentEnvelopeTarget | null>;
+  /** Shows "Expiry and Reminders" for the texted signing link (see `DocumentSigningOptions`); sent as `documents.expiryDays` / `reminderIntervalDays` / `maxReminders`. `null` = off. */
+  readonly documentSigningOptions: import("@angular/core").InputSignal<DocumentSigningOptions | null | undefined>;
+  /** "Preview Document" button(s) in the Documents section call this; `null` hides them. */
+  readonly documentPreview: import("@angular/core").InputSignal<DocumentPreviewHandler | null>;
+  /**
+   * Turns on the video settings (Playback, Call-to-Action, Hide reactions, Watch Preview, Remove Video) once a video is attached, starting
+   * from these defaults, and makes the video link carry them. `null` (default) = the plain share link is inserted, as before.
+   * A text is limited to 320 characters: a link with settings is longer, and Send stays off while the message is over the limit.
+   */
+  readonly videoDefaults: import("@angular/core").InputSignal<VideoDefaults | null>;
   readonly sent: import("@angular/core").OutputEmitterRef<void>;
   readonly phoneAdded: import("@angular/core").OutputEmitterRef<string>;
   readonly validChange: import("@angular/core").OutputEmitterRef<boolean>;
+  /** A document send was refused because the document / envelope changed meanwhile (404 / 409): the host refreshes its list. */
+  readonly rejected: import("@angular/core").OutputEmitterRef<void>;
   readonly MAX_LENGTH = 320;
   mode: 'compose' | 'template';
   body: string;
@@ -3443,6 +4246,8 @@ declare class SendTextComponent implements OnInit {
   /** What the document section holds (null / empty = no documents) and whether it currently breaks a rule. */
   documentsValue: DocumentSendValue | null;
   documentsInvalid: boolean;
+  /** Lines of the merge check ("These fields will be left empty: …"). */
+  mergeWarnings: string[];
   readonly mediaAttachment: import("@angular/core").WritableSignal<{
     url: string;
     mediaType: string;
@@ -3462,6 +4267,17 @@ declare class SendTextComponent implements OnInit {
   get pendingPhoneValid(): boolean;
   /** True when the sender chose at least one document (only possible when the `documents` input is on). */
   get hasDocuments(): boolean;
+  /** The declared context keys with a value (`documents.context`). */
+  readonly forwardedContext: import("@angular/core").Signal<SendContext | undefined>;
+  /** The chosen documents the merge check looks at. */
+  get mergeDocuments(): DocumentOption[];
+  onMergeWarnings(lines: string[]): void;
+  /** The lines of the ONE warning banner: what choosing a document removed, the merge check. */
+  get warningLines(): {
+    key: string;
+    text: string;
+    testId: string | null;
+  }[];
   /** Set when choosing the first document removed something the sender had already added - said out loud (aria-live), never silently. */
   docsRemovedNote: string;
   onDocumentsChange(v: DocumentSendValue): void;
@@ -3482,6 +4298,8 @@ declare class SendTextComponent implements OnInit {
   get resolvedBody(): string;
   /** Template fields the user still has to fill — tags with no non-blank known value and nothing applied. */
   get missingVars(): string[];
+  /** Why Send is off when the video link pushes the text over the SMS limit ('' otherwise). */
+  get videoLengthError(): string;
   /** Compose mode: a `{{…}}` the form can't fill blocks sending (the server would refuse it). */
   get composeTagError(): string;
   /** Missing fields with nothing typed yet — Send stays disabled until this is empty. */
@@ -3510,6 +4328,18 @@ declare class SendTextComponent implements OnInit {
   onFileSelected(event: Event): void;
   removeMedia(): void;
   insertVideo(v: VideoMessage): void;
+  /** The video attached through the settings flow (null = none) and the line it put into the message. */
+  videoPicked: VideoMessage | null;
+  /** Bumped to re-create the video picker (it keeps its own selection and has no clear output). */
+  videoPickerKey: number;
+  private _videoLine;
+  /** The picker's output: with `videoDefaults` the video gets its settings section, otherwise the plain link is inserted as before. */
+  onVideoSelected(v: VideoMessage): void;
+  /** The settings section's output: rewrites the video line of the message with the current link (the rest of the message is untouched). */
+  onVideoLink(link: string): void;
+  /** "Remove Video": takes the video line out of the message and brings the picker back. */
+  removeVideo(): void;
+  private discardVideo;
   submit(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<SendTextComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SendTextComponent, "ui-send-text", never, {
@@ -3548,6 +4378,11 @@ declare class SendTextComponent implements OnInit {
       "required": false;
       "isSignal": true;
     };
+    "documentSentMessage": {
+      "alias": "documentSentMessage";
+      "required": false;
+      "isSignal": true;
+    };
     "documents": {
       "alias": "documents";
       "required": false;
@@ -3568,10 +4403,51 @@ declare class SendTextComponent implements OnInit {
       "required": false;
       "isSignal": true;
     };
+    "documentSigners": {
+      "alias": "documentSigners";
+      "required": false;
+      "isSignal": true;
+    };
+    "sendContext": {
+      "alias": "sendContext";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentContextTypes": {
+      "alias": "documentContextTypes";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentMergeCheck": {
+      "alias": "documentMergeCheck";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentEnvelope": {
+      "alias": "documentEnvelope";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentSigningOptions": {
+      "alias": "documentSigningOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentPreview": {
+      "alias": "documentPreview";
+      "required": false;
+      "isSignal": true;
+    };
+    "videoDefaults": {
+      "alias": "videoDefaults";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "sent": "sent";
     "phoneAdded": "phoneAdded";
     "validChange": "validChange";
+    "rejected": "rejected";
   }, never, never, true, never>;
 }
 /** One match of the host's `jobSearch` function; `description` is the small second line (e.g. the customer). */
@@ -3626,12 +4502,67 @@ export declare class SendMessagePanelComponent {
   /** Purposes the app's backend supports for documents (default all three); `['ESIGN']` hides the purpose select. */
   readonly documentPurposes: import("@angular/core").InputSignal<DocumentSendPurpose[]>;
   /** Documents already chosen when the panel opens (e.g. the row "Send Document" was clicked on); the user can change them. */
-  readonly initialDocuments: import("@angular/core").InputSignal<{
-    id: string;
-    title: string;
-    fileName?: string | null;
-    hasFile?: boolean;
-  }[]>;
+  readonly initialDocuments: import("@angular/core").InputSignal<DocumentSeed[]>;
+  /**
+   * Turns on the signer logic of the Documents section (docs/send-documents-contract.md, Addendum 2026-10-19), all off when `null` (default):
+   *  - a document with MORE THAN ONE customer signer shows one required contact picker per further role (Signer 1 is the recipient), Send
+   *    stays off until every role has a contact, and `documents.signers` (complete, ordered by role) is added to the payload;
+   *  - a document that requires the sender's countersignature shows one read-only line ("Countersigned by <name> after all signers.");
+   *  - a document with no signature fields (`signerRoles: []`) is informational: no signers, countersign line, DocuSign or signing options -
+   *    the recipient gets a view link;
+   *  - DocuSign is offered only for a signed document with one customer signer, and the countersign checkbox is replaced by the document's setting.
+   * The roles come from the `GET /documents` row (`signerRoles`) or from `resolveRoles`. A multi-signer document can't be texted.
+   */
+  readonly documentSigners: import("@angular/core").InputSignal<DocumentSignersConfig | null>;
+  /** Values the host has for THIS send (e.g. `{ propertyId }`); only keys listed in `documentContextTypes` are sent, as `documents.context`. */
+  readonly sendContext: import("@angular/core").InputSignal<SendContext | null>;
+  /** The context keys the app's backend accepts. */
+  readonly documentContextTypes: import("@angular/core").InputSignal<ContextTypeDef[]>;
+  /**
+   * The pre-send "fields that will be empty" check, for documents with mapped data fields only (non-blocking warning): `true` = default route
+   * `POST <baseUrl>/documents/merge-check`, a function = your own call, `false` (default) = off.
+   */
+  readonly documentMergeCheck: import("@angular/core").InputSignal<boolean | MergeCheckFn>;
+  /**
+   * Sends an EXISTING envelope: its documents are fixed (no search, no remove), the recipient is chosen in the panel, and the request is sent
+   * (`POST <baseUrl>/documents/envelopes/{id}/send`, or your `sendEmail` / `sendText` with `documents.envelopeId`) instead of created.
+   * Turns the Documents section on by itself. `null` (default) = a new request from the chosen documents.
+   */
+  readonly documentEnvelope: import("@angular/core").InputSignal<DocumentEnvelopeTarget | null>;
+  /** Builds the success toast of a document send (`"<title>" sent for signature`, `Envelope "<name>" sent` …); the default texts apply when unset. */
+  readonly documentSentMessage: import("@angular/core").InputSignal<DocumentSentMessage | null>;
+  /** false = the app's email sending is switched off (Communication settings): the Email tab says so and Send stays off. Default true. */
+  readonly emailEnabled: import("@angular/core").InputSignal<boolean>;
+  /** The footer button text instead of `Send Email` / `Send Text` (e.g. `Send Document`, `Send Envelope`). */
+  readonly sendLabel: import("@angular/core").InputSignal<string>;
+  /** The 620px wide panel (a long form with signers). Default false. */
+  readonly wide: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Shows "Expiry and Reminders" in the Documents section (Expiry 1-90 days, Reminder Interval 1-30 days, Max Reminders 0-10; required
+   * whole numbers) for native e-signature requests, on the Email tab (purpose e-signature or both) and the Text tab. Pass `{}` for the
+   * defaults 7 / 2 / 3 or set any of `expiryDays`, `reminderIntervalDays`, `maxReminders`. The values are sent as
+   * `documents.expiryDays` / `reminderIntervalDays` / `maxReminders`. `null` (default) = not shown, nothing sent.
+   */
+  readonly documentSigningOptions: import("@angular/core").InputSignal<DocumentSigningOptions | null | undefined>;
+  /**
+   * Email tab: the host says DocuSign is connected (the library never calls `/docusign/status`). Offers "Native E-Sign / Send via DocuSign"
+   * while exactly one document is chosen; DocuSign sends through `POST <baseUrl>/docusign/send` (or your `sendEmail`, which then gets
+   * `documents.provider === 'DOCUSIGN'`). A document row/`initialDocuments` entry with `requiresCountersign: true` also offers "Require my
+   * countersignature after client signs". Default `false` = native only.
+   */
+  readonly docuSignConnected: import("@angular/core").InputSignal<boolean>;
+  /**
+   * "Preview Document" in the Documents section: called with the chosen document when its button is clicked. The library has no route
+   * of its own — the host opens its viewer. Open a tab synchronously inside this function (Safari blocks `window.open` after an await).
+   * `null` (default) = no preview button.
+   */
+  readonly documentPreview: import("@angular/core").InputSignal<DocumentPreviewHandler | null>;
+  /**
+   * The "Video" section (always the last section of the Email and Text forms): once a video is attached it shows Playback, Call-to-Action
+   * (+ URL / label), Hide reactions, Watch Preview and Remove Video, starting from these defaults (your Communication settings), and the
+   * link in the message carries them (`buildVideoLink`). `null` (default) = the plain share link is inserted, with no settings.
+   */
+  readonly videoDefaults: import("@angular/core").InputSignal<VideoDefaults | null>;
   /** The Documents section is shown only when the host turned it on AND the user may send documents. */
   protected readonly documentsOn: import("@angular/core").Signal<boolean>;
   /**
@@ -3655,6 +4586,8 @@ export declare class SendMessagePanelComponent {
   readonly closed: import("@angular/core").OutputEmitterRef<void>;
   readonly sent: import("@angular/core").OutputEmitterRef<void>;
   readonly emailAdded: import("@angular/core").OutputEmitterRef<string>;
+  /** A document / envelope send was refused because it changed meanwhile (404 / 409): the host refreshes its list. */
+  readonly rejected: import("@angular/core").OutputEmitterRef<void>;
   readonly phoneAdded: import("@angular/core").OutputEmitterRef<string>;
   readonly sendEmailRef: import("@angular/core").Signal<SendEmailComponent | undefined>;
   readonly sendTextRef: import("@angular/core").Signal<SendTextComponent | undefined>;
@@ -3785,6 +4718,71 @@ export declare class SendMessagePanelComponent {
       "required": false;
       "isSignal": true;
     };
+    "documentSigners": {
+      "alias": "documentSigners";
+      "required": false;
+      "isSignal": true;
+    };
+    "sendContext": {
+      "alias": "sendContext";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentContextTypes": {
+      "alias": "documentContextTypes";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentMergeCheck": {
+      "alias": "documentMergeCheck";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentEnvelope": {
+      "alias": "documentEnvelope";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentSentMessage": {
+      "alias": "documentSentMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "emailEnabled": {
+      "alias": "emailEnabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "sendLabel": {
+      "alias": "sendLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "wide": {
+      "alias": "wide";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentSigningOptions": {
+      "alias": "documentSigningOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "docuSignConnected": {
+      "alias": "docuSignConnected";
+      "required": false;
+      "isSignal": true;
+    };
+    "documentPreview": {
+      "alias": "documentPreview";
+      "required": false;
+      "isSignal": true;
+    };
+    "videoDefaults": {
+      "alias": "videoDefaults";
+      "required": false;
+      "isSignal": true;
+    };
     "showJobPicker": {
       "alias": "showJobPicker";
       "required": false;
@@ -3810,9 +4808,135 @@ export declare class SendMessagePanelComponent {
     "closed": "closed";
     "sent": "sent";
     "emailAdded": "emailAdded";
+    "rejected": "rejected";
     "phoneAdded": "phoneAdded";
   }, never, never, true, never>;
 }
+/**
+ * ui-document-signers — the signer section of a document send: one required contact per customer signer role of the chosen document
+ * (Signer 1 is the recipient, shown read-only) in signing order, and the one read-only countersign line.
+ *
+ * Internal child of the message forms (`ui-send-message-panel` with `documentSigners`); hosts do not place it. Rows exist only for a
+ * document with MORE THAN ONE customer signer; a single-signer document shows nothing here except the countersign line. It emits the
+ * complete `signers` list (never a partial one: `null` until every role has a contact) and its validity (`UiFieldValidity`):
+ * a missing contact is `<Role label> is required.`, a contact without an email `<Name> has no email address.`, the same person in two
+ * roles `<Name> is already <Role label>.` (unless the config allows it).
+ */
+export declare class DocumentSignersComponent implements UiFieldValidity {
+  /** The signer logic's conclusion for the chosen document(s) (`ui-document-send-options` value `signerInfo`). */
+  readonly info: import("@angular/core").InputSignal<DocumentSignerInfo | null>;
+  readonly config: import("@angular/core").InputSignal<DocumentSignersConfig | null>;
+  /** The recipient of the message = Signer 1. */
+  readonly recipient: import("@angular/core").InputSignal<SignerPick>;
+  /** Shows the "<Role> is required." messages now (otherwise after the first blur). */
+  readonly showErrors: import("@angular/core").InputSignal<boolean>;
+  /** The sender chose DocuSign: only the countersign line applies. */
+  readonly viaDocuSign: import("@angular/core").InputSignal<boolean>;
+  /** The complete signer list (recipient first) or null while a role has no contact. Emitted on every change. */
+  readonly signersChange: import("@angular/core").OutputEmitterRef<SendSigner[] | null>;
+  readonly invalidChange: import("@angular/core").OutputEmitterRef<boolean>;
+  readonly picks: import("@angular/core").WritableSignal<Partial<Record<SignerRole, ContactLookup | null>>>;
+  protected readonly rowsShown: import("@angular/core").Signal<boolean>;
+  protected readonly line: import("@angular/core").Signal<string>;
+  readonly problems: import("@angular/core").Signal<Partial<Record<SignerRole, string>>>;
+  readonly signers: import("@angular/core").Signal<SendSigner[] | null>;
+  readonly errorMessage: import("@angular/core").Signal<string>;
+  readonly invalid: import("@angular/core").Signal<boolean>;
+  constructor();
+  protected label(role: SignerRole): string;
+  /** Under a picker: the problems of a chosen contact (no email / same person twice); the empty-row message is the picker's own (`visibleErrorMessage`). */
+  protected visibleProblem(role: SignerRole): string;
+  pick(role: SignerRole, c: ContactLookup | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentSignersComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentSignersComponent, "ui-document-signers", never, {
+    "info": {
+      "alias": "info";
+      "required": false;
+      "isSignal": true;
+    };
+    "config": {
+      "alias": "config";
+      "required": false;
+      "isSignal": true;
+    };
+    "recipient": {
+      "alias": "recipient";
+      "required": false;
+      "isSignal": true;
+    };
+    "showErrors": {
+      "alias": "showErrors";
+      "required": false;
+      "isSignal": true;
+    };
+    "viaDocuSign": {
+      "alias": "viaDocuSign";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "signersChange": "signersChange";
+    "invalidChange": "invalidChange";
+  }, never, never, true, never>;
+}
+/** Quiet time after the last change before the check is requested. */
+export declare const MERGE_CHECK_DEBOUNCE_MS = 300;
+/**
+ * ui-document-merge-check — the pre-send "fields that will be empty" check (non-blocking), logic only (it renders nothing).
+ *
+ * Internal child of the message forms. While `enabled` is `true` (default route `POST <baseUrl>/documents/merge-check`) or a host
+ * function, and at least one chosen document has mapped data fields, it asks which data fields would be left empty for this recipient,
+ * these signers and this context, and emits the warning lines (`warningsChange`). Debounced, a newer request cancels an older one
+ * (`switchMap`), never cached. A failed or slow check emits no warning and never blocks Send. Documents with no mapped data fields
+ * are not sent to the check.
+ */
+export declare class DocumentMergeCheckComponent {
+  private readonly http;
+  private readonly destroyRef;
+  private readonly apiBase;
+  /** `true` = the default route, a function = the host's own call, `false` / `null` = off. */
+  readonly enabled: import("@angular/core").InputSignal<boolean | MergeCheckFn | null>;
+  readonly documents: import("@angular/core").InputSignal<SignerDocLike[]>;
+  readonly customerId: import("@angular/core").InputSignal<string>;
+  readonly signers: import("@angular/core").InputSignal<SendSigner[] | null>;
+  readonly context: import("@angular/core").InputSignal<SendContext | undefined>;
+  /** The warning lines (empty = nothing to warn about). Emitted whenever they change. */
+  readonly warningsChange: import("@angular/core").OutputEmitterRef<string[]>;
+  private readonly request;
+  constructor();
+  private lastLines;
+  private call;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DocumentMergeCheckComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DocumentMergeCheckComponent, "ui-document-merge-check", never, {
+    "enabled": {
+      "alias": "enabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "documents": {
+      "alias": "documents";
+      "required": false;
+      "isSignal": true;
+    };
+    "customerId": {
+      "alias": "customerId";
+      "required": false;
+      "isSignal": true;
+    };
+    "signers": {
+      "alias": "signers";
+      "required": false;
+      "isSignal": true;
+    };
+    "context": {
+      "alias": "context";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "warningsChange": "warningsChange";
+  }, never, never, true, never>;
+}
 export interface BulkMessageContact {
   id: string;
   name: string;
@@ -4816,7 +5940,7 @@ export declare class FormSectionComponent {
   }, {}, never, ["*"], true, never>;
 }
 export declare class FormRowComponent {
-  readonly cols: import("@angular/core").InputSignal<2 | 1 | 3>;
+  readonly cols: import("@angular/core").InputSignal<1 | 2 | 3>;
   static ɵfac: i0.ɵɵFactoryDeclaration<FormRowComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<FormRowComponent, "ui-form-row", never, {
     "cols": {
@@ -5256,6 +6380,12 @@ export declare class AppShellComponent implements OnInit, OnDestroy {
   private readonly router;
   private _routerSub?;
   readonly navGroups: import("@angular/core").InputSignal<NavGroup[]>;
+  /**
+   * The page's title, rendered in the top bar as the page's single `<h1>` (id `shell-page-title`, `tabindex="-1"` so an app can
+   * focus it after navigation) and used as the accessible name of `<main>`. A page that has no title here keeps its own heading.
+   * A page shown with a title MUST NOT also render its own `<h1>` (that would be two h1s); give it a visually hidden one only
+   * when the title is not set.
+   */
   readonly pageTitle: import("@angular/core").InputSignal<string>;
   readonly appName: import("@angular/core").InputSignal<string>;
   readonly user: import("@angular/core").InputSignal<ShellUser | null>;
@@ -5882,115 +7012,6 @@ export declare class RadioComponent {
     "selected": "selected";
   }, never, ["*"], true, never>;
 }
-export interface RadioOption {
-  value: string;
-  label: string;
-  description?: string;
-  disabled?: boolean;
-}
-/**
- * Group of native radio buttons inside a `<fieldset>` (+ `<legend>` = `label`), a ControlValueAccessor (string value, `''`
- * = nothing selected). Arrow keys move and select natively because all radios share one `name`.
- * Built-in validation: `required` -> "<label> is required."; a non-empty value that is not one of the `options` ->
- * "Select a valid option." (not checked while `options` is empty). Disabled groups are never invalid.
- *
- * Validity API (same on every ui input): Angular `Validator`, signals `invalid` + `errorMessage`, `invalidChange` output,
- * provides `UiFieldValidity`. Messages show after the group lost focus or while `[showErrors]="true"`; a host `[error]` wins.
- */
-export declare class RadioGroupComponent implements ControlValueAccessor, Validator, UiFieldValidity {
-  readonly label: import("@angular/core").InputSignal<string>;
-  readonly options: import("@angular/core").InputSignal<RadioOption[]>;
-  readonly required: import("@angular/core").InputSignal<boolean>;
-  readonly hint: import("@angular/core").InputSignal<string>;
-  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 orientation: import("@angular/core").InputSignal<"vertical" | "horizontal">;
-  /** Native `name` shared by the radios; a unique one is generated when omitted. */
-  readonly name: import("@angular/core").InputSignal<string>;
-  protected readonly _disabledInput: import("@angular/core").InputSignal<boolean>;
-  private readonly _cvaDisabled;
-  protected readonly disabled: import("@angular/core").Signal<boolean>;
-  private readonly _generatedName;
-  protected get _name(): string;
-  protected readonly _descId: string;
-  protected readonly _value: import("@angular/core").WritableSignal<string>;
-  private readonly _reveal;
-  private readonly _issue;
-  /** True while the value 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 ('' when valid), shown or not. */
-  readonly errorMessage: import("@angular/core").Signal<string>;
-  /** Emits whenever the field becomes invalid / valid. */
-  readonly invalidChange: import("@angular/core").OutputEmitterRef<boolean>;
-  protected readonly _activeError: import("@angular/core").Signal<string>;
-  private _onValidatorChange;
-  constructor();
-  /** Re-run the form control's validation when a rule input (required, options) changes. */
-  ngOnChanges(): void;
-  validate(control: AbstractControl): ValidationErrors | null;
-  registerOnValidatorChange(fn: () => void): void;
-  private _onChange;
-  private _onTouched;
-  writeValue(val: string): void;
-  registerOnChange(fn: (v: string) => void): void;
-  registerOnTouched(fn: () => void): void;
-  setDisabledState(d: boolean): void;
-  protected onSelect(value: string): void;
-  /** Touched once focus leaves the whole group (moving between its radios does not count). */
-  protected onFocusOut(event: FocusEvent): void;
-  private _check;
-  static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
-  static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "ui-radio-group", never, {
-    "label": {
-      "alias": "label";
-      "required": false;
-      "isSignal": true;
-    };
-    "options": {
-      "alias": "options";
-      "required": false;
-      "isSignal": true;
-    };
-    "required": {
-      "alias": "required";
-      "required": false;
-      "isSignal": true;
-    };
-    "hint": {
-      "alias": "hint";
-      "required": false;
-      "isSignal": true;
-    };
-    "error": {
-      "alias": "error";
-      "required": false;
-      "isSignal": true;
-    };
-    "showErrors": {
-      "alias": "showErrors";
-      "required": false;
-      "isSignal": true;
-    };
-    "orientation": {
-      "alias": "orientation";
-      "required": false;
-      "isSignal": true;
-    };
-    "name": {
-      "alias": "name";
-      "required": false;
-      "isSignal": true;
-    };
-    "_disabledInput": {
-      "alias": "disabled";
-      "required": false;
-      "isSignal": true;
-    };
-  }, {
-    "invalidChange": "invalidChange";
-  }, never, never, true, never>;
-}
 /** One row of a `ui-radio-matrix`: `value` is the key in the model, `label` the row header. */
 export interface RadioMatrixRow {
   value: string;
@@ -6146,7 +7167,7 @@ export declare class DetailCardComponent {
   /** Bold uppercase title. Empty = no title text. */
   readonly title: import("@angular/core").InputSignal<string>;
   /** 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<2 | 1 | 5 | 3 | 6 | 4 | null>;
+  readonly headingLevel: import("@angular/core").InputSignal<1 | 2 | 3 | 4 | 5 | 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>;
   /** Grey line under the title. */
@@ -6257,4 +7278,4 @@ export declare class DividerComponent {
     };
   }, {}, never, never, true, never>;
 }
-export type { SendDocumentsPayload, SendEmailPayload, SendTextPayload };
+export type { CreateDocumentRequestBody, DocuSignSendBody, DocumentSentInfo, DocumentSentMessage, DocumentsPayloadExtras, ExistingEnvelopeSendBody, SendDocumentsPayload, SendEmailPayload, SendTextPayload, VideoDefaults, VideoLinkOptions };