@forgeroute/ui 0.4.38 → 0.4.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeroute/ui",
-  "version": "0.4.38",
+  "version": "0.4.40",
   "peerDependencies": {
     "@angular/common": ">=22.0.0",
     "@angular/core": ">=22.0.0",

package/types/forgeroute-ui-messaging.d.ts

@@ -115,7 +115,7 @@ export declare class TemplatePickerComponent {
   private readonly host;
   private readonly search$;
   /** Filter results to a specific channel: 'email', 'text', or omit for all. */
-  readonly channel: import("@angular/core").InputSignal<"" | "text" | "email">;
+  readonly channel: import("@angular/core").InputSignal<"" | "email" | "text">;
   readonly selectedId: import("@angular/core").InputSignal<string | null>;
   readonly label: import("@angular/core").InputSignal<string>;
   /** Shows the red required asterisk (same as the library inputs) — e.g. when a template must be picked to send. */
@@ -543,7 +543,7 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
   /** API root from FORGEROUTE_CONFIG (e.g. a cross-origin prod API); falls back to same-origin `/api`. */
   private readonly apiBase;
   /** `email` → purpose select + attachment allowed; `text` → link only (purpose fixed to e-signature). */
-  readonly channel: import("@angular/core").InputSignal<"text" | "email">;
+  readonly channel: import("@angular/core").InputSignal<"email" | "text">;
   readonly label: import("@angular/core").InputSignal<string>;
   /** When true, at least one document must be chosen. The message forms leave it false: documents are optional there. */
   readonly required: import("@angular/core").InputSignal<boolean>;
@@ -608,7 +608,7 @@ export declare class DocumentSendOptionsComponent implements UiFieldValidity {
   /** 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">;
+  readonly envelopeStatus: import("@angular/core").WritableSignal<"idle" | "loading" | "ready" | "error">;
   private envelopeSub;
   private readonly roleSubs;
   /** The sender opened the collapsed "Signing options" line. */
@@ -1813,7 +1813,7 @@ export declare class SendMessagePanelComponent {
   readonly activeContact: import("@angular/core").WritableSignal<MessageContact | null>;
   /** What the sender should know about the picked contact before sending (why a channel is missing, what to add). */
   readonly contactNotices: import("@angular/core").Signal<string[]>;
-  readonly channel: import("@angular/core").WritableSignal<"text" | "email">;
+  readonly channel: import("@angular/core").WritableSignal<"email" | "text">;
   readonly valid: import("@angular/core").WritableSignal<boolean>;
   /** Bumped on every fresh open / new contact — re-creates the email and text forms so no draft carries over. */
   readonly formEpoch: import("@angular/core").WritableSignal<number>;

package/types/forgeroute-ui-stripe.d.ts

@@ -1141,4 +1141,114 @@ export declare class MicrodepositVerifyComponent {
     "verifyFailed": "verifyFailed";
   }, never, never, true, never>;
 }
+/**
+ * "Connect your Stripe account": the one card every app shows where a business connects the Stripe account it collects payments into (Stripe Connect). It reads
+ * the account's state from the app's backend, and Connect asks the backend for the address of Stripe's onboarding page and sends the browser there: the user
+ * finishes setting up the account on Stripe and Stripe sends them back to the address the backend chose. An unfinished onboarding simply shows Connect again
+ * (the backend resumes the same account); a finished one shows Connected with Reconnect.
+ *
+ *   <ui-stripe-connect [connectParams]="{ returnTo: 'setup' }" (statusChange)="onConnected($event)" />
+ *
+ * The backend follows the convention of the setup wizard's `stripe` preset: `GET /integrations/stripe/status` answers `{ connected }` and
+ * `GET /integrations/stripe/connect` answers `{ url }` (`authUrl` / `onboardingUrl` are read too). Both addresses and the texts can be replaced. The calls go
+ * through `FORGEROUTE_CONFIG.baseUrl` and the app's HTTP interceptors (its sign-in token).
+ */
+export declare class StripeConnectComponent {
+  private readonly http;
+  private readonly destroyRef;
+  private readonly apiBase;
+  /** GET: answers `{ connected }`. Relative to `FORGEROUTE_CONFIG.baseUrl`. */
+  readonly statusEndpoint: import("@angular/core").InputSignal<string>;
+  /** GET: answers the address of Stripe's onboarding page (`{ url }`). Relative to `FORGEROUTE_CONFIG.baseUrl`. */
+  readonly connectEndpoint: import("@angular/core").InputSignal<string>;
+  /** Query parameters sent with the connect request (for example `{ returnTo: 'setup' }`: where Stripe sends the user back to). */
+  readonly connectParams: import("@angular/core").InputSignal<Record<string, string> | null>;
+  readonly title: import("@angular/core").InputSignal<string>;
+  readonly description: import("@angular/core").InputSignal<string>;
+  readonly connectedText: import("@angular/core").InputSignal<string>;
+  readonly connectLabel: import("@angular/core").InputSignal<string>;
+  readonly reconnectLabel: import("@angular/core").InputSignal<string>;
+  /** What the user sees when the status or the address could not be loaded and the server gave no message. */
+  readonly loadFailedText: import("@angular/core").InputSignal<string>;
+  readonly connectFailedText: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** The account's state changed (it was read, or read again): true = connected. */
+  readonly statusChange: import("@angular/core").OutputEmitterRef<boolean>;
+  protected readonly connected: import("@angular/core").WritableSignal<boolean>;
+  protected readonly statusKnown: import("@angular/core").WritableSignal<boolean>;
+  protected readonly connecting: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<string>;
+  protected readonly busy: import("@angular/core").Signal<boolean>;
+  private started;
+  constructor();
+  /** Reads the account's state again (after the user came back from Stripe, for example). */
+  refresh(): void;
+  /** Asks the backend for Stripe's onboarding address and sends the browser there. */
+  protected connect(): void;
+  /** Sends the browser to Stripe. */
+  protected redirect(url: string): void;
+  /** Only an http(s) address is ever opened (never `javascript:` or `data:` from a response). */
+  private isWebAddress;
+  private messageOf;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StripeConnectComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StripeConnectComponent, "ui-stripe-connect", never, {
+    "statusEndpoint": {
+      "alias": "statusEndpoint";
+      "required": false;
+      "isSignal": true;
+    };
+    "connectEndpoint": {
+      "alias": "connectEndpoint";
+      "required": false;
+      "isSignal": true;
+    };
+    "connectParams": {
+      "alias": "connectParams";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+    "connectedText": {
+      "alias": "connectedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "connectLabel": {
+      "alias": "connectLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "reconnectLabel": {
+      "alias": "reconnectLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadFailedText": {
+      "alias": "loadFailedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "connectFailedText": {
+      "alias": "connectFailedText";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "statusChange": "statusChange";
+  }, never, never, true, never>;
+}
 export type { HandleReturnOptions, MicrodepositStartedBy, MicrodepositStepsContext, MicrodepositType, MicrodepositVerifyData, MicrodepositVerifyEvent, ProvideStripePaymentOptions, StripeA11yMessages, StripeAppearance, StripeBillingDetails, StripeConfirmResult, StripeConfirmedEvent, StripeConnection, StripeCreateIntentFn, StripeDeferredIntent, StripeElementChange, StripeElementsLike, StripeErrorDisplay, StripeErrorLike, StripeErrorMessageOptions, StripeFailure, StripeFailureStage, StripeIntentKind, StripeIntentLike, StripeLike, StripeLikeWithBankSetup, StripeLoadOptions, StripeLoaderFn, StripeMicrodepositNextAction, StripeMicrodepositResult, StripeOutcome, StripePaymentDefaults, StripePaymentElementLike, StripeReadyEvent, StripeReturnParams, StripeReturnResult, StripeVerification };

package/types/forgeroute-ui.d.ts

@@ -298,6 +298,8 @@ export type BulkUpdateOption<T = any> = string | {
    * It is also the inline select's accessible name, the default confirm's title and confirm button, and the default confirm message reads
    * "<label>: <option> for N items?" (instead of "Change <column> to <option> for N items?"). Host `confirm` copy still wins; its
    * `ctx.columnLabel` stays the column's label. Trimmed; blank = ignored. Ignored for the reserved `delete` key. Omit it and nothing changes.
+   * Direct actions (`action: true`): the bar button text, default confirm title and confirm button (required in practice; trimmed,
+   * blank = the key split on `_`, `-` and camelCase with only the first word capitalised: 'resend' -> 'Resend', 'send_reminder' / 'sendReminder' -> 'Send reminder'); `ctx.columnLabel` is this label.
    *
    *   { field: 'state', label: 'Archive / Restore' }
    */
@@ -330,8 +332,32 @@ export type BulkUpdateOption<T = any> = string | {
    *   { field: 'status', allowedFrom: { SENT: ['DRAFT'] }, canChange: (row, target) => target !== 'SENT' || canSend(row) }
    */
   canChange?: (row: T, target: string) => boolean;
+  /**
+   * Direct bulk action (`{ field: 'resend', action: true, label: 'Resend' }`): a bulk-bar button that is neither a field change nor
+   * Delete. `field` is the action key (no column needed), the button type is `action-<field>` and there is no inline select.
+   * Clicking it opens the library confirm, then POSTs `<endpoint>/bulk/<field>` with exactly `{ ids }` (the eligible rows). The response is
+   * handled like a field change (`updated`, `skipped`, `notAllowed`, readable `message`). Ignored for the reserved `delete` key.
+   * Read-only users get no bulk bar, so nothing changes for them. Omit it and nothing changes.
+   * `confirm` on an action takes only the function form; a map (target value -> function) is ignored and the default copy is used.
+   *
+   *   { field: 'resend', action: true, label: 'Resend', eligible: (row: Request) => row.status === 'PENDING' }
+   */
+  action?: boolean;
+  /** Direct action only: button style, default 'secondary'. 'danger' also makes the default confirm button red. */
+  variant?: 'secondary' | 'danger';
+  /**
+   * Direct action only: true when the server will accept the action for this row (keep it identical to the backend rule). Rows it
+   * refuses are skipped (counted, NEVER sent; "N selected rows don't qualify for <label lower-cased> and will be skipped."). When no selected loaded row passes,
+   * the button is disabled with a visible reason ("None of the selected rows qualify for <label lower-cased>."). Omit it and every selected row is sent. A predicate that throws counts as "row not eligible" (never breaks rendering).
+   */
+  eligible?: (row: T) => boolean;
+  /**
+   * Direct action only: the past-tense word in the result toast. "N <doneLabel>, M skipped." when anything was skipped / not allowed,
+   * else "N <itemLabel>(s) <doneLabel>.". Default 'updated'.
+   */
+  doneLabel?: string;
 };
-/** What a bulk confirm function receives. For bulk Delete: `targetValue`/`targetLabel` are '', `columnLabel` is 'Delete', skipped counts are 0. */
+/** 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> {
   /** Rows that WILL be sent (eligible). For Delete: the selected count. */
   count: number;
@@ -391,6 +417,12 @@ export interface BulkActionDef {
   deletable?: (row: any) => boolean;
   /** Field changes: per-row check that the server will accept the move to a target (from `{ field, canChange }`). */
   canChange?: (row: any, target: string) => boolean;
+  /** True for a direct bulk action (from `{ field, action: true, label }`); `type` is `action-<key>` and `field` is not set (no inline select). */
+  action?: boolean;
+  /** Direct action: which rows the server will accept (from `{ field, action: true, eligible }`). */
+  eligible?: (row: any) => boolean;
+  /** Direct action: past-tense word in the result toast (from `{ doneLabel }`), default 'updated'. */
+  doneLabel?: string;
   /**
    * 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.
@@ -1210,6 +1242,10 @@ export declare class ImportExportComponent {
   private readonly apiBase;
   private readonly toast;
   private readonly cdr;
+  private readonly destroyRef;
+  /** Seconds since the import request started (shown while it runs). */
+  importElapsed: number;
+  private importTimer;
   constructor();
   exporting: boolean;
   exportAll(): void;
@@ -1237,6 +1273,7 @@ export declare class ImportExportComponent {
   closeImport(): void;
   finishImport(): void;
   onFileChange(event: Event): void;
+  private readCsvFile;
   private autoMap;
   get canSubmit(): boolean;
   get unmappedRequiredFields(): string[];
@@ -1247,6 +1284,7 @@ export declare class ImportExportComponent {
   goToPreview(): void;
   get mappedFields(): ImportFieldDef[];
   get previewRows(): Record<string, string>[];
+  private stopImportTimer;
   submitImport(): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<ImportExportComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<ImportExportComponent, "ui-import-export", never, {
@@ -1386,6 +1424,10 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
    * `[{ field: 'status', exclude: ['EXPIRED'] }, 'delete']` (see `BulkUpdateOption`).
    * Use `{ field, allowedFrom: { TARGET: [sourceValues] } }` for a status workflow: only targets some selected row can
    * legally move to are offered, and rows that can't move are skipped (never sent).
+   * Use `{ field: 'resend', action: true, label: 'Resend', eligible?, confirm?, variant?, doneLabel? }` for a direct bulk action: a bar button
+   * that confirms and POSTs `<endpoint>/bulk/<field>` with `{ ids }` of the eligible rows (no select, no column needed).
+   * A blank `label` falls back to the key split on `_`, `-` and camelCase with only the first word capitalised ('send_reminder' -> 'Send reminder');
+   * two actions with the same key collapse to the first; an `eligible` that throws counts as "row not eligible".
    */
   readonly bulkUpdateOptions: import("@angular/core").InputSignal<BulkUpdateOption<T>[]>;
   readonly rowClick: import("@angular/core").OutputEmitterRef<T>;
@@ -1576,9 +1618,14 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
   /**
    * Derives internal action definitions from the `bulkUpdateOptions` string array.
    * 'delete' → built-in danger action with table-managed confirm dialog.
+   * `{ field, action: true, label }` → direct action (type `action-<key>`, no column needed, no select).
    * Everything else → matched to a column: label = the entry's `label` when given, else "Change {col.label}"; options from column config.
    */
   protected readonly _bulkDefs: Signal<BulkActionDef[]>;
+  /** Fallback label of a direct action without one: splits the key on `_`, `-` and camelCase, capitalises the first word only ('send_reminder' / 'sendReminder' -> 'Send reminder'). */
+  private _actionKeyLabel;
+  /** Runs a direct action's `eligible` predicate; a predicate that throws counts as "row not eligible". */
+  private _isActionEligible;
   /** Options for a field-based bulk action: the field's options minus the entry's `exclude` values. */
   private _bulkOptionsFor;
   /** True when a row whose field currently holds `current` may be moved to `target` by this action. */
@@ -1632,12 +1679,20 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
    * skipped-rows sentence, appended on a new paragraph unless the copy sets `omitSkippedNote`.
    */
   private _hostConfirm;
-  /** Why a bulk action can't be used right now ('' = it can). Only Delete with `deletable` can be blocked. */
+  /** 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;
   /** 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. */
   private _deleteSplit;
+  /** Selected rows (loaded page) split by a direct action's `eligible` predicate; without it every selected row is eligible. */
+  private _actionSplit;
+  /** Type of the direct bulk action whose request is in flight (null = none). */
+  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;
+  /** Direct bulk action: confirm, then POST `<endpoint>/bulk/<key>` with `{ ids }` of the eligible rows. */
+  private _runDirectAction;
   /** 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). */
@@ -1686,6 +1741,11 @@ export declare class DataTableComponent<T extends Record<string, any>> implement
    */
   private _fetchCounts;
   ngOnInit(): void;
+  /**
+   * Retry from the error state. A failed table shows no search box or quick tabs (there is nothing to search), so a search term that was
+   * active when the request failed could not be cleared any more: the retry therefore asks for the unsearched list on page 1.
+   */
+  protected _retryAfterError(): void;
   protected onSearchChange(val: string): void;
   /** Phone sort control: "Default" (value '') + one entry per sortable visible column and direction ("<key>:asc|desc"). */
   protected readonly _phoneSortOptions: Signal<{
@@ -6025,7 +6085,11 @@ export interface DropdownItem {
   count?: number;
   /** Greyed-out, not selectable and skipped by keyboard navigation. */
   disabled?: boolean;
+  /** Optional 14px icon before the label: an SVG path (the `d` value, like a toolbar action's `icon`). Decorative (hidden from assistive tech). */
+  icon?: string;
 }
+/** Which edge of the trigger the menu lines up with: `auto` (default) opens from the trigger's left edge and switches to its right edge when the menu would run off the right of the screen. */
+export type DropdownAlign = 'auto' | 'start' | 'end';
 export declare class DropdownComponent {
   readonly label: import("@angular/core").InputSignal<string>;
   readonly items: import("@angular/core").InputSignal<DropdownItem[]>;
@@ -6042,12 +6106,19 @@ export declare class DropdownComponent {
    */
   readonly ariaLabel: import("@angular/core").InputSignal<string>;
   readonly itemClick: import("@angular/core").OutputEmitterRef<DropdownItem>;
+  /** Which edge of the trigger the menu lines up with (default `auto`: from the left edge, switching to the right edge when it would run off the screen). */
+  readonly align: import("@angular/core").InputSignal<DropdownAlign>;
   protected readonly open: import("@angular/core").WritableSignal<boolean>;
   protected readonly loading: import("@angular/core").WritableSignal<boolean>;
+  /** Placement measured when the menu opens: right-aligned, above the trigger, and the height left on that side (the menu scrolls inside it). */
+  protected readonly alignEnd: import("@angular/core").WritableSignal<boolean>;
+  protected readonly openUp: import("@angular/core").WritableSignal<boolean>;
+  protected readonly menuMaxHeight: import("@angular/core").WritableSignal<number | null>;
   private readonly _loaded;
   private readonly _id;
   private readonly _host;
   private readonly _cdr;
+  private readonly _injector;
   private _pendingFocus;
   private _typeahead;
   private _typeaheadTimer;
@@ -6077,6 +6148,12 @@ export declare class DropdownComponent {
   protected onMenuKeydown(event: KeyboardEvent): void;
   protected onEscape(event: Event): void;
   private _setOpen;
+  /**
+   * Places the open menu from its measured size and the trigger's screen position: it keeps 16px clear of the screen edges, lines up with the trigger's
+   * right edge instead of the left when that is the side with room (`align` = auto), opens above the trigger when there is more room there, and is capped to
+   * the room left on that side (so it scrolls inside only when it truly does not fit). No layout APIs (server rendering) = the default placement.
+   */
+  private _place;
   private _openAndFocus;
   /** Renders the menu synchronously, then focuses the pending first / last enabled item. */
   private _focusPending;
@@ -6125,6 +6202,11 @@ export declare class DropdownComponent {
       "required": false;
       "isSignal": true;
     };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "itemClick": "itemClick";
   }, never, never, true, never>;
@@ -7169,8 +7251,8 @@ export declare class PanelInfoListComponent {
  * readers announce it as pressed / not pressed. A dismissible chip is a removable tag, not a toggle, so it carries no
  * `aria-pressed` (the ✕ button is named "Remove <label>").
  *
- * Dismissible chips can be removed from the keyboard: Tab to the ✕ (focusable, named "Remove <label>") and press Enter or
- * Space, or press Delete / Backspace while the chip itself is focused.
+ * A dismissible chip is a wrapper of two sibling native buttons (the label and the ✕), never a button inside a button (axe nested-interactive).
+ * Keyboard removal: Tab to the ✕ (named "Remove <label>") and press Enter or Space, or press Delete / Backspace on either button.
  *
  * Dismissible (shows an ✕ button — parent removes the chip on dismiss):
  *   <ui-chip label="Austin" size="sm" [dismissible]="true" (dismiss)="removeCity('Austin')" />
@@ -7210,10 +7292,7 @@ export declare class ChipComponent implements ControlValueAccessor {
   protected _onTouched: () => void;
   protected onClick(): void;
   protected onDismiss(event: Event): void;
-  /**
-   * Keyboard removal: Enter / Space on the focused ✕, or Delete / Backspace on the chip itself (dismissible chips only).
-   * Handled here so the key never also toggles the chip.
-   */
+  /** Delete / Backspace on either button of a dismissible chip removes it (the ✕ itself is a native button: Enter / Space click it). */
   protected onDismissKey(event: Event): void;
   writeValue(v: boolean): void;
   registerOnChange(fn: (v: boolean) => void): void;
@@ -9201,6 +9280,8 @@ export declare class DetailCardComponent {
   readonly editAriaLabel: import("@angular/core").InputSignal<string>;
   /** true = the card fills the height of its container (a grid cell / flex item) so sibling cards line up; the body grows. Spacing between cells comes from the gap: the filled card's margin-bottom is 0. Default false: unchanged. */
   readonly fill: import("@angular/core").InputSignal<boolean>;
+  /** Max height of the card body (any CSS length, e.g. `360px`): a longer body scrolls inside the card so the card never gets crazy long. Empty = no limit (or the `--dc-body-max-height` custom property, which a page can set on the card or an ancestor). */
+  readonly maxBodyHeight: import("@angular/core").InputSignal<string>;
   /** true = a click on the card (outside interactive controls and text selections) toggles `selected`. The card must contain its own checkbox for keyboard / screen-reader users. Default false: no handler, cursor or outline. */
   readonly selectable: import("@angular/core").InputSignal<boolean>;
   /** Two-way: whether the card is selected (only shown / toggled when `selectable`). */
@@ -9315,6 +9396,11 @@ export declare class DetailCardComponent {
       "required": false;
       "isSignal": true;
     };
+    "maxBodyHeight": {
+      "alias": "maxBodyHeight";
+      "required": false;
+      "isSignal": true;
+    };
     "selectable": {
       "alias": "selectable";
       "required": false;
@@ -11227,7 +11313,7 @@ export interface IntegrationPlainText {
 export declare function integrationPlainText(html: string): IntegrationPlainText;
 /**
  * How a connect button for an integration works.
- *  - `oauth`: GET `authorizeEndpoint` answers `{ url }` and the browser goes there (QuickBooks, Slack, Gmail, Outlook, Google / Outlook calendar).
+ *  - `oauth`: GET `authorizeEndpoint` answers `{ url }` (or `{ authUrl }`) and the browser goes there (QuickBooks, Slack, Gmail, Outlook, Google / Outlook calendar, Stripe, Square).
  *  - `area-code`: asks for a US area code and POSTs `{ areaCode }` to `connectEndpoint` (Twilio buys a number that way); the status is reloaded after.
  */
 export type SetupIntegrationConnect = {
@@ -11331,7 +11417,7 @@ export interface SetupStep {
   skippable?: boolean;
   /** `custom`: runs on "Save & Continue". Resolve to continue; throw / error to stay on the step (the message is shown in an alert). */
   save?: () => Observable<unknown> | Promise<unknown> | void;
-  /** `custom`: false disables "Save & Continue". */
+  /** `custom` and `integrations`: false disables "Save & Continue" (read on every render, so it can follow signals). */
   canContinue?: () => boolean;
   /** `custom`: text of the continue button (default "Save & Continue"). */
   saveLabel?: string;
@@ -11370,7 +11456,9 @@ export interface SetupWizardApi {
   markCompleted(...keys: string[]): void;
 }
 /**
- * The integrations every app can offer in a setup step. The endpoints follow the convention the apps' backends already use (`GET <x>/status`,
+ * The integrations every app can offer in a setup step. Payment processing (`stripe`, `square`) belongs in almost every app's wizard:
+ * `setupIntegrations('stripe', 'square')` is the ready-made "connect payments" step (an app that has one processor passes just that one; the
+ * backend answers 409 when the other is already connected, and the step shows it). The endpoints follow the convention the apps' backends already use (`GET <x>/status`,
  * `GET <x>/authorize` answering `{ url }`); an app whose routes differ spreads a preset and overrides what differs:
  * `{ ...SETUP_INTEGRATIONS['quickbooks'], statusEndpoint: '/accounting/status' }`.
  */
@@ -11524,6 +11612,11 @@ export declare class SetupWizardComponent {
   protected back(): void;
   protected skip(): void;
   /** Marks the given steps done (ignoring keys that are not steps of this wizard). */
+  /**
+   * Marks steps as done from outside the step templates (unknown keys are ignored), e.g. when the app finds that a step's data already exists after a
+   * page reload, so the user is not asked to import it a second time. Same effect as `wizard.markCompleted(...)` inside a step template.
+   */
+  completeSteps(...keys: string[]): void;
   private markStepsCompleted;
   private markCompleted;
   /** "Save & Continue" of a custom or integrations step: runs the step's hook, then moves on. */
@@ -11546,6 +11639,7 @@ export declare class SetupWizardComponent {
   protected detailFor(i: SetupIntegration): string;
   protected connect(i: SetupIntegration): void;
   private startConnect;
+  private isWebAddress;
   /** SVG path of a library icon (the buttons' leading / trailing glyph). */
   protected iconD(name: string): string;
   protected areaCodeLabelFor(i: SetupIntegration): string;
@@ -12073,6 +12167,11 @@ export declare const MAX_EMAIL_ADDRESS_LENGTH = 254;
 export declare const isValidEmailAddress: (address: string) => boolean;
 /** An http(s) address with a real host: no spaces or quotes (the address is written into an HTML attribute) and a dot or `localhost`. */
 export declare function isWebUrl(raw: string): boolean;
+/**
+ * How many characters typed text takes once it is saved, i.e. as `innerHTML` writes a TEXT node: `&`, `<` and `>` become entities and a
+ * non-breaking space (what a browser types for a run of spaces) becomes `&nbsp;`; quotes are not escaped in text, so each counts as one.
+ */
+export declare function serializedTextLength(text: string): number;
 /** Escapes text for HTML text and double-quoted attribute values. */
 export declare function escapeHtml(value: string): string;
 /** True when a block's HTML shows something to a reader: an image or other media, or text once tags, non-breaking spaces and whitespace are gone. */