@forgeroute/ui 0.4.40 → 0.4.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeroute/ui",
-  "version": "0.4.40",
+  "version": "0.4.41",
   "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<"" | "email" | "text">;
+  readonly channel: import("@angular/core").InputSignal<"" | "text" | "email">;
   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<"email" | "text">;
+  readonly channel: import("@angular/core").InputSignal<"text" | "email">;
   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<"idle" | "loading" | "ready" | "error">;
+  readonly envelopeStatus: import("@angular/core").WritableSignal<"error" | "loading" | "ready" | "idle">;
   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<"email" | "text">;
+  readonly channel: import("@angular/core").WritableSignal<"text" | "email">;
   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

@@ -1,5 +1,6 @@
 import * as i0 from "@angular/core";
-import { InjectionToken, Provider } from "@angular/core";
+import { DestroyRef, InjectionToken, Provider, WritableSignal } from "@angular/core";
+import { Observable } from "rxjs";
 /**
  * The small part of Stripe.js the library calls, written as plain structural types so the library has NO compile-time or run-time
  * dependency on `@stripe/stripe-js` outside of the lazy loader (`stripe-loader.ts`). The real `Stripe` object satisfies these; so does a hand-written fake.
@@ -1141,104 +1142,213 @@ export declare class MicrodepositVerifyComponent {
     "verifyFailed": "verifyFailed";
   }, never, never, true, never>;
 }
+/** What the account-status call answers (the shape of cremo's `GET /organizations/connect/status`). `isComplete` = Stripe accepts charges and payouts. */
+interface StripeConnectStatus {
+  isComplete: boolean;
+  detailsSubmitted?: boolean;
+  /** The address of Stripe's onboarding page for an unfinished account. */
+  onboardingUrl?: string;
+}
+/** What the create-account call answers (cremo's `POST /organizations/connect/create`): the new (or resumed) account and the address of Stripe's onboarding page. */
+interface StripeConnectAccount {
+  accountId: string;
+  onboardingUrl: string;
+}
+/**
+ * What happened after the user pressed a button or the page asked for the state. The flow never shows toasts itself (each app has its own): the host words
+ * each outcome, and decides what follows a finished account (for example switching payment collection on).
+ *
+ *  - `complete`: Stripe accepts the account. `source: 'check'` = after "Check Status"; `'resume'` = "Complete Setup" found it already complete; `'return'` =
+ *    the state was read again when the user came back to this tab (`refreshOnReturn`).
+ *  - `verifying`: the details were submitted and Stripe is reviewing them.
+ *  - `incomplete`: "Check Status" found an unfinished onboarding (`onboardingUrl` present).
+ *  - `link-unavailable`: the answer had no https Stripe address; nothing was opened.
+ *  - `failed`: a call failed (`action` says which); `error` is what it threw.
+ */
+type StripeConnectOutcome = {
+  kind: 'complete';
+  source: 'check' | 'resume' | 'return';
+} | {
+  kind: 'verifying';
+  source: 'check' | 'resume' | 'return';
+} | {
+  kind: 'incomplete';
+} | {
+  kind: 'link-unavailable';
+} | {
+  kind: 'failed';
+  action: 'start' | 'check' | 'resume';
+  error: unknown;
+};
+/** The state the flow reads and writes: signals owned by the host (or by the card's two-way models). */
+interface StripeConnectState {
+  accountId: WritableSignal<string | null>;
+  complete: WritableSignal<boolean>;
+  detailsSubmitted: WritableSignal<boolean>;
+  loading: WritableSignal<boolean>;
+}
+interface StripeConnectFlowOptions {
+  /** Read at call time, so a host can swap the call. Null = no call yet (`start()` does nothing). */
+  createAccount: () => (() => Observable<StripeConnectAccount>) | null;
+  getStatus: () => (() => Observable<StripeConnectStatus>) | null;
+  state: StripeConnectState;
+  /** Where outcomes go. */
+  emit: (outcome: StripeConnectOutcome) => void;
+  /** The buttons and methods do nothing while this says true (a read-only user). */
+  disabled?: () => boolean;
+  /** How THIS tab is sent to Stripe when the browser refused the new tab (default `window.location.href = url`). */
+  navigate?: (url: string) => void;
+  destroyRef: DestroyRef;
+}
+/** Only an https address on stripe.com or a real subdomain (never `evilstripe.com` / `connect.stripe.com.evil.com`, `http:`, `javascript:`). */
+export declare function isStripeUrl(url: string | undefined): url is string;
+/**
+ * The Stripe Connect flow of cremo Settings > Payment & Billing, as a plain class: create the account, "Check Status", "Complete Setup", and the "back from Stripe" read.
+ * `ui-stripe-connect` runs it behind its card; a host that has to start the flow from code before any view exists (Settings: the first change-detection pass with
+ * `?connect=return`) creates its own instance over the same state signals. Stripe's page always opens in a NEW tab opened inside the click (a tab opened after the
+ * request is blocked by popup blockers); only an https Stripe address is opened; a failed call closes the empty tab.
+ */
+export declare class StripeConnectFlow {
+  private readonly o;
+  /** A Stripe tab was opened: the card reads the state again when the user comes back (`refreshOnReturn`). */
+  tabOpened: boolean;
+  constructor(o: StripeConnectFlowOptions);
+  private get blocked();
+  /** Creates (or resumes) the account and opens Stripe's onboarding page in a new tab. */
+  start(): void;
+  /** "Check Status": reads the state; a finished or submitted account updates the card, an unfinished one is reported. */
+  check(): void;
+  /** "Complete Setup": reads the state and opens the onboarding address of an unfinished account in a new tab (a finished or submitted one just updates the card). */
+  resume(): void;
+  /** The state read when the user came back to this tab: silent unless something finished or was submitted. */
+  readStatusOnReturn(): void;
+  private openStripe;
+  /** The empty tab, opened inside the click and cut from this page (`opener`); null when the browser refused. */
+  openBlankTab(): Window | null;
+  /** The browser refused the new tab: Stripe opens in this one. */
+  private navigateCurrentTab;
+  private closeTab;
+}
+/**
+ * The default wording of an outcome (the texts cremo Settings has always used), for apps that just want a toast: `{ variant, message }`, or null when
+ * nothing should be said. `completeText` replaces the sentence of a finished account when the host has more to say about what follows.
+ */
+export declare function stripeConnectNotice(outcome: StripeConnectOutcome): {
+  variant: 'success' | 'info' | 'error';
+  message: string;
+} | null;
 /**
- * "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.
+ * "Stripe Connect Account": the card where a business connects the Stripe account it collects payments into (cremo Settings > Payment & Billing, built here
+ * once so every app and the setup wizard show and run the SAME flow). The host owns the data (its two calls and the three state values); the component owns
+ * the screen and the flow:
  *
- *   <ui-stripe-connect [connectParams]="{ returnTo: 'setup' }" (statusChange)="onConnected($event)" />
+ *  - no account yet (`accountId` empty): nothing is shown (the host has its own entry point and calls `start()`), or with `showWhenNoAccount` a card with
+ *    "Set Up Payment Account";;
+ *  - account, not complete, nothing submitted: warning "Account setup incomplete" with "Complete Setup" (asks the status for the onboarding address and opens it);
+ *  - details submitted, not complete: info "Stripe is verifying your account" with "Check Status";
+ *  - complete: success "Account setup complete" with the account id and "View Stripe Dashboard".
  *
- * 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).
+ * Stripe's onboarding page always opens in a NEW tab: the empty tab is opened inside the click (a tab opened after the request is blocked by popup
+ * blockers) and receives the address when it arrives; with the tab refused the address opens in the current tab. Only an https Stripe address is ever opened,
+ * never one an answer made up (`javascript:`, `data:`). A failed call closes the empty tab.
+ *
+ *   <ui-stripe-connect [(accountId)]="accountId" [(complete)]="complete" [(detailsSubmitted)]="submitted"
+ *     [createAccount]="createAccount" [getStatus]="getStatus" [showWhenNoAccount]="true" (outcome)="onOutcome($event)" />
+ *
+ * where `createAccount = () => http.post<StripeConnectAccount>('/connect/create', {})` and `getStatus = () => http.get<StripeConnectStatus>('/connect/status')`.
  */
 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>;
+  /** The call that creates the organization's Stripe account (or resumes it) and answers its id and the onboarding address. Needed for `start()`. */
+  readonly createAccount: import("@angular/core").InputSignal<(() => Observable<StripeConnectAccount>) | null>;
+  /** The call that reads the account's state. Needed for `check()`, `resume()` and `refreshOnReturn`. */
+  readonly getStatus: import("@angular/core").InputSignal<(() => Observable<StripeConnectStatus>) | null>;
+  /** The Stripe account's id (null / empty = no account yet). Two-way: the component sets it when `start()` created the account. */
+  readonly accountId: import("@angular/core").ModelSignal<string | null>;
+  /** Stripe accepts the account (charges and payouts on). Two-way: set by `check()` / `resume()`. */
+  readonly complete: import("@angular/core").ModelSignal<boolean>;
+  /** The details were submitted and Stripe is reviewing them. Two-way: set by `check()` / `resume()`. */
+  readonly detailsSubmitted: import("@angular/core").ModelSignal<boolean>;
   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>;
+  /** Shows the card (with "Set Up Payment Account") while there is no account yet. Default false: hosts with their own entry point show nothing and call `start()`. */
+  readonly showWhenNoAccount: import("@angular/core").InputSignal<boolean>;
+  readonly startTitle: import("@angular/core").InputSignal<string>;
+  readonly startText: import("@angular/core").InputSignal<string>;
+  readonly startLabel: import("@angular/core").InputSignal<string>;
+  /** The buttons cannot be pressed (a read-only user). */
   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;
+  /** After a Stripe tab was opened, the state is read again when this tab becomes visible again (the user came back): `(outcome)` then reports `complete` / `verifying` with source `return`. */
+  readonly refreshOnReturn: import("@angular/core").InputSignal<boolean>;
+  /** The page "View Stripe Dashboard" opens. */
+  readonly dashboardUrl: import("@angular/core").InputSignal<string>;
+  /** What happened (see {@link StripeConnectOutcome}); the host words it. */
+  readonly outcome: import("@angular/core").OutputEmitterRef<StripeConnectOutcome>;
+  /** A request is running: the buttons show "Loading..." / "Checking..." and cannot be pressed again. Two-way, so a host that shows the state elsewhere can read it. */
+  readonly loading: import("@angular/core").ModelSignal<boolean>;
+  /** How the current tab is sent to Stripe when the browser refused the new tab (default: `window.location.href = url`); a host can route it through its own method. */
+  readonly navigateTab: import("@angular/core").InputSignal<((url: string) => void) | null>;
+  protected readonly visible: import("@angular/core").Signal<boolean>;
+  private readonly flow;
   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;
+  /** Creates (or resumes) the account and opens Stripe's onboarding page in a new tab. */
+  start(): void;
+  /** "Check Status": reads the state; a finished or submitted account updates the card, an unfinished one is reported. */
+  check(): void;
+  /** "Complete Setup": reads the state and opens the onboarding address of an unfinished account in a new tab. */
+  resume(): void;
+  /** Opens the Stripe dashboard in a new tab. */
+  openDashboard(): void;
+  /** The browser refused the new tab: Stripe opens in this one (through the host's `navigateTab` when it gave one). */
+  protected navigateCurrentTab(url: string): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<StripeConnectComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<StripeConnectComponent, "ui-stripe-connect", never, {
-    "statusEndpoint": {
-      "alias": "statusEndpoint";
+    "createAccount": {
+      "alias": "createAccount";
       "required": false;
       "isSignal": true;
     };
-    "connectEndpoint": {
-      "alias": "connectEndpoint";
+    "getStatus": {
+      "alias": "getStatus";
       "required": false;
       "isSignal": true;
     };
-    "connectParams": {
-      "alias": "connectParams";
+    "accountId": {
+      "alias": "accountId";
       "required": false;
       "isSignal": true;
     };
-    "title": {
-      "alias": "title";
+    "complete": {
+      "alias": "complete";
       "required": false;
       "isSignal": true;
     };
-    "description": {
-      "alias": "description";
+    "detailsSubmitted": {
+      "alias": "detailsSubmitted";
       "required": false;
       "isSignal": true;
     };
-    "connectedText": {
-      "alias": "connectedText";
+    "title": {
+      "alias": "title";
       "required": false;
       "isSignal": true;
     };
-    "connectLabel": {
-      "alias": "connectLabel";
+    "showWhenNoAccount": {
+      "alias": "showWhenNoAccount";
       "required": false;
       "isSignal": true;
     };
-    "reconnectLabel": {
-      "alias": "reconnectLabel";
+    "startTitle": {
+      "alias": "startTitle";
       "required": false;
       "isSignal": true;
     };
-    "loadFailedText": {
-      "alias": "loadFailedText";
+    "startText": {
+      "alias": "startText";
       "required": false;
       "isSignal": true;
     };
-    "connectFailedText": {
-      "alias": "connectFailedText";
+    "startLabel": {
+      "alias": "startLabel";
       "required": false;
       "isSignal": true;
     };
@@ -1247,8 +1357,32 @@ export declare class StripeConnectComponent {
       "required": false;
       "isSignal": true;
     };
+    "refreshOnReturn": {
+      "alias": "refreshOnReturn";
+      "required": false;
+      "isSignal": true;
+    };
+    "dashboardUrl": {
+      "alias": "dashboardUrl";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+    "navigateTab": {
+      "alias": "navigateTab";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
-    "statusChange": "statusChange";
+    "accountId": "accountIdChange";
+    "complete": "completeChange";
+    "detailsSubmitted": "detailsSubmittedChange";
+    "outcome": "outcome";
+    "loading": "loadingChange";
   }, 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 };
+export type { HandleReturnOptions, MicrodepositStartedBy, MicrodepositStepsContext, MicrodepositType, MicrodepositVerifyData, MicrodepositVerifyEvent, ProvideStripePaymentOptions, StripeA11yMessages, StripeAppearance, StripeBillingDetails, StripeConfirmResult, StripeConfirmedEvent, StripeConnectAccount, StripeConnectFlowOptions, StripeConnectOutcome, StripeConnectState, StripeConnectStatus, 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

@@ -7599,6 +7599,8 @@ export declare class AlertComponent {
    * Default false: the body is a flex row with a gap, exactly as before (use it for text plus a button).
    */
   readonly inline: import("@angular/core").InputSignal<boolean>;
+  /** The box fills the height of its parent cell (two alerts in one grid row get the same height whatever their text length). Default false. */
+  readonly fill: import("@angular/core").InputSignal<boolean>;
   readonly dismissed: import("@angular/core").OutputEmitterRef<void>;
   static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "ui-alert", never, {
@@ -7637,6 +7639,11 @@ export declare class AlertComponent {
       "required": false;
       "isSignal": true;
     };
+    "fill": {
+      "alias": "fill";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "dismissed": "dismissed";
   }, never, ["*"], true, never>;
@@ -9466,6 +9473,55 @@ export declare class DividerComponent {
     };
   }, {}, never, never, true, never>;
 }
+export type FixedFooterAlign = 'start' | 'center' | 'end' | 'between';
+/**
+ * A footer bar fixed to the bottom of the page: it stays visible while the page scrolls, sits flush with the bottom of the viewport
+ * and spans the full width of the content area (from the side nav to the end of the screen). Put it as the LAST child of the page:
+ *
+ *   <div class="settings-page">
+ *     ...the page content...
+ *     <ui-fixed-footer>
+ *       <ui-button variant="primary" (click)="save()">Save All Settings</ui-button>
+ *     </ui-fixed-footer>
+ *   </div>
+ *
+ * How it works: the bar is `position: sticky` at the bottom of the scrolling page. Inside `ui-app-shell` the content area is padded
+ * (24px / 16px / 12px by width) and the shell publishes that padding as `--shell-content-padding`; the footer cancels it with negative
+ * margins and a negative `bottom`, so it reaches the viewport edges instead of stopping inside the padding. Outside the shell the
+ * variable is unset (0px) and the bar simply sticks to the bottom of its scrolling parent. Nothing else needs to be set up.
+ *
+ * Inputs:
+ *  - `align` (default `end`): where the projected content sits: start | center | end | between.
+ *  - `ariaLabel` (default `Page actions`): the accessible name of the bar (a labelled region).
+ *  - `elevated` (default true): the soft shadow above the bar; false = just the top border.
+ * Theming by CSS custom properties: `--ui-footer-bg` (white), `--ui-footer-border` (#e2e8f0), `--ui-footer-pad-y` (20px; 16px up to 1024px, 14px up to 480px).
+ */
+export declare class FixedFooterComponent {
+  /** Where the projected content sits in the bar. */
+  readonly align: import("@angular/core").InputSignal<FixedFooterAlign>;
+  /** Accessible name of the bar. */
+  readonly ariaLabel: import("@angular/core").InputSignal<string>;
+  /** The soft shadow above the bar (false = only the top border). */
+  readonly elevated: import("@angular/core").InputSignal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FixedFooterComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<FixedFooterComponent, "ui-fixed-footer", never, {
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "elevated": {
+      "alias": "elevated";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
 /** One column (stage) of a [ui-board]. `items` are the host's own records; the board never reads their fields. */
 export interface BoardColumn<T = unknown> {
   /** Unique id of the column (the stage key); reported in `from` / `to` of a move. */
@@ -11313,12 +11369,13 @@ export interface IntegrationPlainText {
 export declare function integrationPlainText(html: string): IntegrationPlainText;
 /**
  * How a connect button for an integration works.
- *  - `oauth`: GET `authorizeEndpoint` answers `{ url }` (or `{ authUrl }`) and the browser goes there (QuickBooks, Slack, Gmail, Outlook, Google / Outlook calendar, Stripe, Square).
+ *  - `oauth`: GET `authorizeEndpoint` answers `{ url }` (or `{ authUrl }`) and the browser goes there (in a NEW tab with `newTab: true`, opened inside the click so popup blockers allow it, else in this tab) (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 = {
   type: 'oauth';
   authorizeEndpoint: string;
+  newTab?: boolean;
 } | {
   type: 'area-code';
   connectEndpoint: string;
@@ -11365,6 +11422,8 @@ export interface SetupWizardTexts {
   selectSource: string;
   connected: string;
   importMore: string;
+  /** The link on an import step (before data came in) that downloads the template CSV: the header row and the config's `templateSampleRows`, so the user can add their data to it. */
+  downloadSample: string;
   /** Shown (and described by the disabled Continue) on an import step with `requireImport` until data came in. */
   importRequired: string;
   /** An import where some rows were refused: the warning's title and text (rows that failed must be fixed and imported again before Continue) and the button that returns to the sources. */
@@ -11394,6 +11453,8 @@ export interface SetupImportStep {
   buttonLabel: string;
   /** Hint above the button. */
   hint?: string;
+  /** Text of the template download link, e.g. "Download Products/Services CSV Template" (default: the `downloadSample` text, "Download CSV Template"). The file is this step's own template: the config's field labels and `templateSampleRows`. */
+  templateLabel?: string;
   /** Result alert title, built from the number imported (default `${n} ${config.entityNamePlural.toLowerCase()} imported successfully.`). */
   resultTitle?: (imported: number) => string;
   /** Result alert body. */
@@ -11560,6 +11621,8 @@ export declare class SetupWizardComponent {
   readonly steps: import("@angular/core").InputSignal<SetupStep[]>;
   /** Replaces any of the built-in texts. */
   readonly texts: import("@angular/core").InputSignal<Partial<SetupWizardTexts>>;
+  /** The key of the step to open first (for example the one a payment provider's return address names); default (empty or unknown) = the first step. Read once, when the wizard starts. */
+  readonly initialStep: import("@angular/core").InputSignal<string>;
   /** The last step's button ("Go to Dashboard"). */
   readonly finished: import("@angular/core").OutputEmitterRef<void>;
   /** "Exit Setup". */
@@ -11579,6 +11642,12 @@ export declare class SetupWizardComponent {
   private readonly importErrors;
   private readonly statuses;
   readonly busy: import("@angular/core").WritableSignal<boolean>;
+  /** Key of the integration whose authorization address is being requested: only that card's button shows a loader (the footer's Save & Continue is not busy), and no second press starts a second connection. */
+  protected readonly connecting: import("@angular/core").WritableSignal<string>;
+  /** The blank tab opened on the Connect click (the click is the user gesture; the address arrives later), or null when none was opened / the browser blocked it. */
+  private pendingTab;
+  /** A provider's page was opened in another tab: when this tab becomes visible again the step's statuses are read again. */
+  private connectTabOpened;
   /** What a custom step's template receives (`let-wizard`). */
   protected readonly api: SetupWizardApi;
   protected readonly error: import("@angular/core").WritableSignal<string>;
@@ -11626,6 +11695,8 @@ export declare class SetupWizardComponent {
   private messageOf;
   /** A source card was picked on the step itself: opens the import window already past its source step (at the upload step for that source). */
   protected startImport(key: string, source: string): void;
+  /** The sample CSV (the import window's template): the field labels as the header row and the config's example rows. */
+  protected downloadSample(): void;
   protected openImport(key: string): void;
   protected onImported(key: string): void;
   protected importResult(key: string): number | null;
@@ -11638,13 +11709,18 @@ export declare class SetupWizardComponent {
   protected isConnected(i: SetupIntegration): boolean;
   protected detailFor(i: SetupIntegration): string;
   protected connect(i: SetupIntegration): void;
+  /** Opens an empty tab for the provider's page (null when the browser refuses; the address then opens in this tab). */
+  protected openTab(): Window | null;
+  private closePendingTab;
   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;
-  /** Sends the browser to the provider's authorization page. */
+  /** Opens the provider's authorization page: in the tab opened on the click, else (a blocked tab) in this one. */
   protected redirect(url: string): void;
+  /** Sends THIS tab to the address (no new tab was opened, the browser refused it or the user closed it). */
+  protected navigateHere(url: string): void;
   protected submitAreaCode(i: SetupIntegration): void;
   static ɵfac: i0.ɵɵFactoryDeclaration<SetupWizardComponent, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<SetupWizardComponent, "ui-setup-wizard", never, {
@@ -11658,6 +11734,11 @@ export declare class SetupWizardComponent {
       "required": false;
       "isSignal": true;
     };
+    "initialStep": {
+      "alias": "initialStep";
+      "required": false;
+      "isSignal": true;
+    };
   }, {
     "finished": "finished";
     "exited": "exited";