@forgeroute/ui 0.4.3 → 0.4.5

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

@@ -0,0 +1,1144 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, Provider } from "@angular/core";
+/**
+ * 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.
+ */
+/** A Stripe.js error object (`result.error`). */
+interface StripeErrorLike {
+  type?: string;
+  code?: string;
+  decline_code?: string;
+  message?: string;
+}
+/** The `next_action` of an intent that needs the customer to verify a bank account with micro-deposits. */
+interface StripeMicrodepositNextAction {
+  arrival_date?: number;
+  hosted_verification_url?: string;
+  microdeposit_type?: string;
+}
+/** A PaymentIntent or a SetupIntent as returned by Stripe.js (only the fields the library reads). */
+interface StripeIntentLike {
+  id: string;
+  status: string;
+  client_secret?: string | null;
+  amount?: number;
+  payment_method?: string | {
+    id: string;
+  } | null;
+  next_action?: {
+    type?: string;
+    verify_with_microdeposits?: StripeMicrodepositNextAction;
+  } | null;
+}
+interface StripePaymentElementLike {
+  mount(target: string | HTMLElement): void;
+  destroy(): void;
+  on(event: string, handler: (event: any) => void): void;
+  update?(options: Record<string, unknown>): void;
+}
+interface StripeElementsLike {
+  create(type: 'payment', options?: Record<string, unknown>): StripePaymentElementLike;
+  submit(): Promise<{
+    error?: StripeErrorLike;
+  }>;
+  update?(options: Record<string, unknown>): void;
+  fetchUpdates?(): Promise<{
+    error?: StripeErrorLike;
+  }>;
+}
+interface StripeConfirmResult<I> {
+  error?: StripeErrorLike;
+  paymentIntent?: I;
+  setupIntent?: I;
+}
+/** The Stripe.js object (`Stripe`). Methods the library calls only in some flows are optional so a fake can leave them out. */
+interface StripeLike {
+  elements(options?: Record<string, unknown>): StripeElementsLike;
+  confirmPayment(params: Record<string, unknown>): Promise<StripeConfirmResult<StripeIntentLike>>;
+  confirmSetup(params: Record<string, unknown>): Promise<StripeConfirmResult<StripeIntentLike>>;
+  handleCardAction?(clientSecret: string): Promise<StripeConfirmResult<StripeIntentLike>>;
+  retrievePaymentIntent?(clientSecret: string): Promise<StripeConfirmResult<StripeIntentLike>>;
+  retrieveSetupIntent?(clientSecret: string): Promise<StripeConfirmResult<StripeIntentLike>>;
+  verifyMicrodepositsForPayment?(clientSecret: string, data?: Record<string, unknown>): Promise<StripeConfirmResult<StripeIntentLike>>;
+  verifyMicrodepositsForSetup?(clientSecret: string, data?: Record<string, unknown>): Promise<StripeConfirmResult<StripeIntentLike>>;
+}
+/** The second argument of `loadStripe(key, options)`. */
+interface StripeLoadOptions {
+  /** A Stripe Connect account id (`acct_...`): direct charges / saved methods on the connected account. */
+  stripeAccount?: string;
+  locale?: string;
+  apiVersion?: string;
+  betas?: string[];
+}
+/**
+ * Loads Stripe.js: `loader(publishableKey, options)` resolves the `Stripe` object (or `null` when it could not be created).
+ * It is called exactly like `loadStripe(key, options)` from `@stripe/stripe-js`: the second argument is `undefined` unless a Connect
+ * account / locale / other option is set.
+ */
+type StripeLoaderFn = (publishableKey: string, options?: StripeLoadOptions) => Promise<StripeLike | null>;
+/** The dynamic import of the Stripe SDK, behind an object so a spec can replace it (internal: not part of the public API). */
+declare const sdkImporter: {
+  load: () => Promise<{
+    loadStripe: (key: string, options?: never) => Promise<unknown>;
+  }>;
+};
+/**
+ * The default loader. `@stripe/stripe-js` is imported lazily (a dynamic import), so the Stripe SDK is only downloaded when a
+ * payment form is actually shown, and it is an optional peer dependency of the library.
+ */
+export declare const defaultStripeLoader: StripeLoaderFn;
+/** How Stripe.js is loaded. Provide your own to fake Stripe in tests or to load it differently. Defaults to `defaultStripeLoader`. */
+export declare const STRIPE_LOADER: InjectionToken<StripeLoaderFn>;
+/** App-wide defaults for every `ui-stripe-payment`, set once with `provideStripePayment`. A value on the component always wins. */
+interface StripePaymentDefaults {
+  /** The publishable key (`pk_...`), used when the component has no `publishableKey` of its own. */
+  publishableKey?: string;
+  /** Stripe.js locale (`'en'`, `'es'`, ...): passed to `loadStripe` as `{ locale }`. */
+  locale?: string;
+}
+export declare const STRIPE_PAYMENT_DEFAULTS: InjectionToken<StripePaymentDefaults>;
+interface ProvideStripePaymentOptions extends StripePaymentDefaults {
+  /** Replaces how Stripe.js is loaded (tests, a self-hosted loader). */
+  loader?: StripeLoaderFn;
+}
+/**
+ * Global defaults for the Stripe components:
+ *
+ *   providers: [provideStripePayment({ publishableKey: environment.stripePublishableKey, locale: 'en' })]
+ */
+export declare function provideStripePayment(options?: ProvideStripePaymentOptions): Provider[];
+/** `loadStripe`'s second argument for a Connect account / locale / extra options; `undefined` when there is nothing to pass (like the apps do today). */
+export declare function buildLoadOptions(stripeAccount: string | null | undefined, locale: string | null | undefined, extra?: StripeLoadOptions | null): StripeLoadOptions | undefined;
+/**
+ * Plain-language text for the Stripe decline / error codes (https://docs.stripe.com/declines/codes). One table for every app; an app can replace single entries
+ * with the `errorMessages` input of `ui-stripe-payment` (or the `overrides` option of `getStripeErrorMessage`).
+ */
+export declare const STRIPE_ERROR_MESSAGES: Readonly<Record<string, string>>;
+/** Text for the Stripe error types that are about Stripe or the connection, never about the customer's input (Stripe's own text there is technical). */
+export declare const STRIPE_TECHNICAL_ERROR_MESSAGES: Readonly<Record<string, string>>;
+export declare const STRIPE_DEFAULT_ERROR_MESSAGE = "Payment failed. Please try again.";
+declare const STRIPE_ALREADY_PROCESSED_MESSAGE = "This payment has already been processed. Please refresh the page and try again.";
+declare const STRIPE_SESSION_EXPIRED_MESSAGE = "Your payment session has expired. Please refresh the page and try again.";
+type StripeErrorDisplay = 'friendly' | 'table' | 'stripe';
+interface StripeErrorMessageOptions {
+  /**
+   * `'friendly'` (default): the table above first, then Stripe's own text for card / validation errors (customer-facing) and plain text for technical errors.
+   * `'table'`: the table, then Stripe's own `message` for EVERYTHING else, technical errors included (what the cremo payment flows show today).
+   * `'stripe'`: Stripe's own `message` untouched (what the apps that show `error.message` do), the fallback when there is none.
+   */
+  display?: StripeErrorDisplay;
+  /** Text for single codes; wins over the table. */
+  overrides?: Readonly<Record<string, string>> | null;
+  /** Shown when there is nothing better. */
+  fallback?: string;
+}
+/**
+ * The text to show the customer for a Stripe.js error.
+ * Friendly mode order: decline_code, code, the two technical Stripe messages ("already succeeded" / "previously confirmed", "expired"),
+ * technical error types, Stripe's own message, the fallback. Table mode is the same without the technical error types.
+ */
+export declare function getStripeErrorMessage(error: StripeErrorLike | null | undefined, options?: StripeErrorMessageOptions): string;
+type StripeIntentKind = 'setup' | 'payment';
+/**
+ * What happened, in one word:
+ * - `succeeded`: the intent succeeded (card charged / method saved).
+ * - `processing`: the payment was accepted and is settling (a bank debit takes days).
+ * - `requires_verification`: a bank account was entered by number; Stripe sent micro-deposits and the customer has to verify them (see `verification`).
+ * - `requires_action`: the intent still needs the customer to do something else (3D Secure, a redirect-less next action).
+ * - `requires_capture`: the payment is authorized and waits for the host to capture it (`captureMethod: 'manual'`).
+ * - `requires_payment_method`: Stripe sends the intent back for a new payment method (the payment failed).
+ * - `canceled` / `unknown`: any other status.
+ */
+type StripeOutcome = 'succeeded' | 'processing' | 'requires_verification' | 'requires_action' | 'requires_capture' | 'requires_payment_method' | 'canceled' | 'unknown';
+/** What the customer has to do to verify a bank account (`next_action.verify_with_microdeposits`). */
+interface StripeVerification {
+  /** `'amounts'` (two deposits), `'descriptor_code'` (one deposit with a code) or `null` when Stripe did not say. */
+  type: 'amounts' | 'descriptor_code' | null;
+  /** When the deposits should have arrived: Unix seconds as Stripe sends it, and the same instant as an ISO string. `null` when unknown. */
+  arrivalDate: number | null;
+  arrivalDateIso: string | null;
+  /** Stripe's own page where the customer can verify (https), or `null`. */
+  hostedVerificationUrl: string | null;
+}
+/** The normalised result of a confirmation (or of `handleReturn`). */
+interface StripeConfirmedEvent {
+  kind: StripeIntentKind;
+  /** Stripe's own `status` of the intent. */
+  status: string;
+  outcome: StripeOutcome;
+  /** The intent exactly as Stripe.js returned it. */
+  intent: StripeIntentLike;
+  setupIntent?: StripeIntentLike;
+  paymentIntent?: StripeIntentLike;
+  intentId: string;
+  /** The payment method of the intent as an id (`pm_...`), whether Stripe sent it as a string or an object; `null` when there is none. */
+  paymentMethodId: string | null;
+  /** Set when `outcome` is `requires_verification`. */
+  verification: StripeVerification | null;
+  /** The 3D Secure step (`stripe.handleCardAction`) ran before this result (`autoHandleCardAction` / `handleNextAction`). Hosts use it for their post-3DS wording. */
+  actionHandled: boolean;
+}
+/** Why a flow stopped. */
+type StripeFailureStage = 'load' | 'submit' | 'intent' | 'confirm' | 'action' | 'result' | 'verify' | 'return';
+/** A failure: `message` is what to show the customer; `stripeMessage` is Stripe's own text. */
+interface StripeFailure {
+  code: string;
+  message: string;
+  stripeMessage: string;
+  declineCode?: string;
+  type?: string;
+  stage: StripeFailureStage;
+  /** The Stripe error as returned, when there was one. */
+  error?: StripeErrorLike;
+  /** True when the failure happened in or after the 3D Secure step. */
+  actionHandled?: boolean;
+  /** Stripe's status of the intent when the failure is about the intent's status (`requires_payment_method`, `canceled`, ...). */
+  status?: string;
+}
+/** The payment method type the Payment Element currently shows (`'card'`, `'us_bank_account'`, ...) and its completeness. */
+interface StripeElementChange {
+  complete: boolean;
+  empty: boolean;
+  /** The selected payment method type, `null` when Stripe did not send one. */
+  type: string | null;
+  /** Stripe's own validation message for the form, when it shows one. */
+  errorMessage: string | null;
+}
+declare const MSG_NOT_INITIALIZED = "Payment system not initialized";
+declare const MSG_INTENT_FAILED = "Failed to create payment intent";
+declare const MSG_NOT_COMPLETED = "Payment was not completed";
+declare const MSG_REQUIRES_PAYMENT_METHOD = "Payment failed. Please try a different payment method.";
+declare const MSG_NO_PAYMENT_METHOD = "No payment method returned from Stripe";
+declare const MSG_AUTH_FAILED = "Payment authentication failed";
+declare const MSG_AUTH_NOT_COMPLETED = "Payment authentication was not completed";
+declare const MSG_KEY_MISSING = "A Stripe publishable key is required";
+declare const MSG_LOAD_FAILED = "Failed to load Stripe";
+export declare function paymentMethodIdOf(intent: StripeIntentLike | null | undefined): string | null;
+/** The micro-deposit verification of an intent whose `next_action` is `verify_with_microdeposits`, else `null`. */
+export declare function verificationOf(intent: StripeIntentLike | null | undefined): StripeVerification | null;
+/** Stripe's intent `status` (and `next_action`) as one `StripeOutcome`. */
+export declare function outcomeOf(intent: StripeIntentLike): StripeOutcome;
+export declare function normalizeIntent(kind: StripeIntentKind, intent: StripeIntentLike): StripeConfirmedEvent;
+/** A failure from a Stripe error, with the text to show chosen by `display` (see `getStripeErrorMessage`). */
+declare function failureFromError(error: StripeErrorLike | null | undefined, stage: StripeFailureStage, options?: StripeErrorMessageOptions): StripeFailure;
+/** A failure that is not a Stripe error (our own text). */
+declare function failure(code: string, message: string, stage: StripeFailureStage, stripeMessage?: string): StripeFailure;
+/** An error thrown by a host callback or a request: its own `error.error.message` (HTTP body), `message`, else the fallback. */
+declare function messageOfThrown(err: unknown, fallback: string): string;
+/** The Stripe object with `confirmUsBankAccountSetup`, for an app that keeps its own routing-number form (contractor). Use it as the type argument of `StripePaymentService.load`. */
+interface StripeLikeWithBankSetup extends StripeLike {
+  confirmUsBankAccountSetup(clientSecret: string, data?: Record<string, unknown>): Promise<StripeConfirmResult<StripeIntentLike>>;
+}
+/** What `stripe.verifyMicrodepositsFor*` takes: the two deposit amounts in cents, or the 6-character code of the one deposit. */
+type MicrodepositVerifyData = {
+  amounts: number[];
+} | {
+  descriptor_code: string;
+};
+interface StripeMicrodepositResult {
+  /** The intent is verified (`processing` or `succeeded`). */
+  ok: boolean;
+  outcome: StripeOutcome | null;
+  intent: StripeIntentLike | null;
+  /** Set when `ok` is false. `message` is Stripe's own text (customer-facing for a wrong amount / code) or ours. */
+  failure: StripeFailure | null;
+}
+/** What Stripe appends to the return URL after a redirect (`payment_intent_client_secret` / `setup_intent_client_secret`, `redirect_status`). */
+interface StripeReturnParams {
+  kind: StripeIntentKind;
+  clientSecret: string;
+  redirectStatus: string | null;
+}
+/** Reads the intent Stripe returned the customer with from a query string (`location.search`); `null` when there is none. */
+export declare function readStripeReturnParams(search: string): StripeReturnParams | null;
+declare const MSG_VERIFY_FAILED = "Verification failed";
+declare const MSG_VERIFY_THROWN = "Verification failed. Please check the code and try again.";
+declare const MSG_RETURN_FAILED = "We could not check the status of this payment. Please contact support before trying again.";
+/**
+ * Verifies a bank account with micro-deposits through Stripe.js (`verifyMicrodepositsForPayment` / `verifyMicrodepositsForSetup`), the way the public
+ * "verify your bank" pages do it with the intent's client secret. The result is `ok` once the intent is `processing` or `succeeded`.
+ */
+export declare function verifyMicrodeposits(stripe: StripeLike, flow: StripeIntentKind, clientSecret: string, data: MicrodepositVerifyData): Promise<StripeMicrodepositResult>;
+interface StripeReturnResult {
+  event: StripeConfirmedEvent | null;
+  failure: StripeFailure | null;
+}
+/** Retrieves the intent after Stripe redirected the customer back (`retrievePaymentIntent` / `retrieveSetupIntent`) and normalises it. */
+export declare function retrieveIntent(stripe: StripeLike, kind: StripeIntentKind, clientSecret: string): Promise<StripeReturnResult>;
+interface StripeConnection {
+  publishableKey?: string | null;
+  /** A Stripe Connect account id. */
+  stripeAccount?: string | null;
+  locale?: string | null;
+  /** Further `loadStripe` options. */
+  options?: StripeLoadOptions | null;
+}
+interface HandleReturnOptions extends StripeConnection {
+  /** The client secret from the return URL. Default: read from `search`. */
+  clientSecret?: string;
+  /** Which kind of intent `clientSecret` belongs to (default: from the URL parameter name, else `'payment'`). */
+  kind?: StripeIntentKind;
+  /** The query string to read the return parameters from. Default: `window.location.search`. */
+  search?: string;
+}
+/**
+ * Stripe.js without a component: loads Stripe like `ui-stripe-payment` does, verifies micro-deposits and checks the intent after a redirect.
+ * For pages that only verify a bank account (the "verify your bank" link) or only land on the `returnUrl`.
+ */
+export declare class StripePaymentService {
+  private readonly loader;
+  private readonly defaults;
+  /** Loads Stripe.js (`loadStripe(key, options)`). Pass a type for methods the library does not use: `load<StripeLikeWithBankSetup>(...)` (contractor's `confirmUsBankAccountSetup`). Throws when the key is missing or Stripe could not be created. */
+  load<T extends StripeLike = StripeLike>(connection?: StripeConnection): Promise<T>;
+  verifyMicrodepositsForPayment(clientSecret: string, data: MicrodepositVerifyData, connection?: StripeConnection): Promise<StripeMicrodepositResult>;
+  verifyMicrodepositsForSetup(clientSecret: string, data: MicrodepositVerifyData, connection?: StripeConnection): Promise<StripeMicrodepositResult>;
+  /** The intent the customer returned with, normalised. `{ event: null, failure: null }` when the URL carries no intent. */
+  handleReturn(options?: HandleReturnOptions): Promise<StripeReturnResult>;
+  private verify;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StripePaymentService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * The Payment Element `appearance` for the page's own look: Stripe's variables read from CSS custom properties at runtime, so one set of
+ * tokens styles the page and the payment form, in light and dark.
+ *
+ *   :root { --ui-stripe-color-primary: #0d9488; --ui-stripe-border-radius: 8px; }
+ *
+ * Variables read (all optional; a missing one is left out so Stripe's default stays): `--ui-stripe-color-primary`, `--ui-stripe-color-background`,
+ * `--ui-stripe-color-text`, `--ui-stripe-color-danger`, `--ui-stripe-font-family`, `--ui-stripe-border-radius`, `--ui-stripe-font-size-base`.
+ * The theme is `night` when the page is dark (`data-theme="dark"`, or the system is dark and `data-theme` is not `light`), else `stripe`.
+ */
+interface StripeAppearance {
+  theme?: 'stripe' | 'night' | 'flat';
+  variables?: Record<string, string>;
+  rules?: Record<string, Record<string, string>>;
+  labels?: 'above' | 'floating';
+  disableAnimations?: boolean;
+}
+/** True when the page is in dark mode: `data-theme="dark"` on the root, or the system prefers dark and the root is not forced to `light`. */
+export declare function isDarkPage(doc: Document): boolean;
+/** Builds the appearance from the tokens in effect on `element` (default: the document root). */
+export declare function readStripeAppearance(doc: Document, element?: Element): StripeAppearance;
+/** The texts of the screen-reader status region. */
+interface StripeA11yMessages {
+  loading: string;
+  savingMethod: string;
+  processingPayment: string;
+  methodSaved: string;
+  paymentReceived: string;
+  paymentProcessing: string;
+  paymentAuthorized: string;
+  verificationNeeded: string;
+  actionRequired: string;
+}
+export declare const STRIPE_A11Y_MESSAGES: Readonly<StripeA11yMessages>;
+/** The exact text shown while the bank-account tab is selected. */
+export declare const STRIPE_ACH_NOTICE = "Signing in to your bank account lets you pay right away. Entering your routing and account numbers instead requires verification with two small deposits, which typically take a couple of days to arrive in your account.";
+/**
+ * "Deferred intent" Elements: the form is shown first, the PaymentIntent / SetupIntent is created on the host's backend when the customer submits.
+ * Maps to `stripe.elements({ mode, amount, currency, setup_future_usage, payment_method_types, ... })`.
+ */
+interface StripeDeferredIntent {
+  /** Default: the component's `mode`. */
+  mode?: 'payment' | 'setup' | 'subscription';
+  /** Smallest currency unit (cents). Changing it later calls `elements.update({ amount })` (no re-init). */
+  amount?: number;
+  currency: string;
+  setupFutureUsage?: 'on_session' | 'off_session';
+  captureMethod?: 'automatic' | 'automatic_async' | 'manual';
+  onBehalfOf?: string;
+}
+/** Called on submit in deferred mode: create the intent on your backend and resolve its client secret (or `{ clientSecret }`). */
+type StripeCreateIntentFn = (context: {
+  mode: StripeIntentKind;
+}) => Promise<string | {
+  clientSecret: string;
+}>;
+interface StripeBillingDetails {
+  name?: string;
+  email?: string;
+  phone?: string;
+  address?: Record<string, string | null | undefined>;
+}
+/**
+ * The live Stripe.js objects of a form, handed to the host by `(stripeReady)`: the host's own code can call `stripe.confirmPayment({ elements, ... })`,
+ * `elements.submit()`, `elements.update()`, `elements.fetchUpdates()` and `paymentElement.update()` with its own arguments.
+ */
+interface StripeReadyEvent {
+  stripe: StripeLike;
+  elements: StripeElementsLike;
+  paymentElement: StripePaymentElementLike;
+}
+/**
+ * Stripe Payment Element: saves a payment method (`mode="setup"`, a SetupIntent) or takes a payment (`mode="payment"`, a PaymentIntent).
+ *
+ * The host app creates the intent on its backend and passes the `clientSecret` (or, for a deferred intent, `[deferred]` + `[createIntent]`).
+ * Stripe.js is loaded lazily through `@stripe/stripe-js` (an optional peer dependency); nothing of Stripe is in the library's static imports.
+ *
+ *   <ui-stripe-payment mode="setup" [publishableKey]="key" [clientSecret]="secret()" submitLabel="Save card"
+ *     (confirmed)="onSaved($event)" (failed)="onFailed($event)" />
+ *
+ * Every Stripe.js call and option reproduces what the CRM apps do today; see docs/stripe.md ("Parity with the existing app implementations").
+ */
+export declare class StripePaymentComponent {
+  private readonly loader;
+  private readonly defaults;
+  private readonly doc;
+  private readonly isBrowser;
+  private readonly host;
+  /**
+   * Mount-only mode: the component only mounts the Payment Element. No submit button, skeleton, status text (unless `a11yMessages` is set), bank notice or error
+   * alert; it never submits, confirms or updates by itself; load failures go to `(loadError)` only. The host keeps its own confirm code and calls Stripe.js with the
+   * objects from `(stripeReady)`. `mountId` / `mountClass` still apply, and `(ready)`, `(elementChange)`, `(paymentMethodTypeChange)` still emit.
+   */
+  readonly mountOnly: import("@angular/core").InputSignal<boolean>;
+  /** `'setup'` saves a payment method (`confirmSetup`), `'payment'` takes a payment (`confirmPayment`). */
+  readonly mode: import("@angular/core").InputSignal<StripeIntentKind>;
+  /** The publishable key (`pk_...`). Falls back to `provideStripePayment({ publishableKey })`. */
+  readonly publishableKey: import("@angular/core").InputSignal<string | null>;
+  /** The client secret of the SetupIntent / PaymentIntent your backend created. Changing it re-creates the form. */
+  readonly clientSecret: import("@angular/core").InputSignal<string | null>;
+  /** Deferred intent: show the form first, create the intent on submit with `createIntent`. Used instead of `clientSecret`. */
+  readonly deferred: import("@angular/core").InputSignal<StripeDeferredIntent | null>;
+  /** Creates the intent on submit (deferred mode) and resolves its client secret. */
+  readonly createIntent: import("@angular/core").InputSignal<StripeCreateIntentFn | null>;
+  /** A Stripe Connect account id (`acct_...`): `loadStripe(key, { stripeAccount })`. */
+  readonly stripeAccount: import("@angular/core").InputSignal<string | null>;
+  /** Stripe.js locale. */
+  readonly locale: import("@angular/core").InputSignal<string | null>;
+  /** Further `loadStripe` options. */
+  readonly stripeOptions: import("@angular/core").InputSignal<StripeLoadOptions | null>;
+  /** Payment method types for a DEFERRED intent (`elements({ payment_method_types })`). With a client secret the intent decides, nothing is passed. */
+  readonly paymentMethodTypes: import("@angular/core").InputSignal<string[] | null>;
+  /** Extra `stripe.elements()` options, merged last. */
+  readonly elementsOptions: import("@angular/core").InputSignal<Record<string, unknown> | null>;
+  /** `'tabs'` (default), `'accordion'`, an object, or `null` to pass no layout. */
+  readonly layout: import("@angular/core").InputSignal<string | Record<string, unknown> | null>;
+  readonly paymentMethodOrder: import("@angular/core").InputSignal<string[] | null>;
+  /** `{ applePay: 'never', googlePay: 'never' }` hides the wallets. */
+  readonly wallets: import("@angular/core").InputSignal<Record<string, string> | null>;
+  /** `{ billingDetails: { email: 'never', phone: 'never', address: 'auto' } }` etc. */
+  readonly fields: import("@angular/core").InputSignal<Record<string, unknown> | null>;
+  /** Pre-filled values: `{ billingDetails: { name, email, address: { country: 'US' } } }`. A later change updates the element in place. */
+  readonly defaultValues: import("@angular/core").InputSignal<Record<string, unknown> | null>;
+  readonly business: import("@angular/core").InputSignal<{
+    name: string;
+  } | null>;
+  readonly terms: import("@angular/core").InputSignal<Record<string, string> | null>;
+  /** Extra Payment Element options, merged last (readOnly, fields, ...). */
+  readonly paymentElementOptions: import("@angular/core").InputSignal<Record<string, unknown> | null>;
+  /** The Elements appearance. */
+  readonly appearance: import("@angular/core").InputSignal<StripeAppearance | null>;
+  /** Derive the appearance from the `--ui-stripe-*` CSS tokens (light / dark) when no `appearance` is set. */
+  readonly appearanceFromTokens: import("@angular/core").InputSignal<boolean>;
+  /** Where Stripe sends the customer back after a redirect. Unset = the current page (`window.location.href`); `null` = pass no `return_url`. */
+  readonly returnUrl: import("@angular/core").InputSignal<string | null | undefined>;
+  /** Billing details sent on confirm (`confirmParams.payment_method_data.billing_details`), needed for fields hidden with `'never'`. */
+  readonly billingDetails: import("@angular/core").InputSignal<StripeBillingDetails | null>;
+  /** Extra `confirmParams`, merged last. */
+  readonly confirmParams: import("@angular/core").InputSignal<Record<string, unknown> | null>;
+  /** `'if_required'` (default) keeps the customer on the page unless the method needs a redirect. */
+  readonly redirect: import("@angular/core").InputSignal<"if_required" | "always">;
+  /** Call `elements.submit()` before confirming. Unset = automatic: yes for a deferred intent (Stripe requires it), no with a client secret. */
+  readonly submitBeforeConfirm: import("@angular/core").InputSignal<boolean | null>;
+  /** After a payment comes back `requires_action` (not a bank verification), run `stripe.handleCardAction` (3D Secure) before reporting. */
+  readonly autoHandleCardAction: import("@angular/core").InputSignal<boolean>;
+  readonly submitLabel: import("@angular/core").InputSignal<string>;
+  /** Show the built-in submit button; turn off to use your own and call `confirm()`. */
+  readonly showSubmit: import("@angular/core").InputSignal<boolean>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** The host is still creating the intent: show the loading skeleton. */
+  readonly pending: import("@angular/core").InputSignal<boolean>;
+  /** Accessible name of the payment form. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** The `id` of the element container (an app's e2e selector such as `#payment-element`). */
+  readonly mountId: import("@angular/core").InputSignal<string>;
+  /** Extra CSS classes on the element container. */
+  readonly mountClass: import("@angular/core").InputSignal<string>;
+  /** Show the bank-account notice while that tab is selected. */
+  readonly showAchNotice: import("@angular/core").InputSignal<boolean>;
+  readonly achNotice: import("@angular/core").InputSignal<string>;
+  /** The `data-testid` of the notice (an app's existing e2e selector, e.g. `ach-setup-notice`). */
+  readonly achNoticeTestId: import("@angular/core").InputSignal<string>;
+  /** The payment method type the host shows before Stripe reports one (cremo: `'card'`); `paymentMethodTypeChange` fires only when the reported type differs from it (or from the last report). */
+  readonly initialPaymentMethodType: import("@angular/core").InputSignal<string>;
+  /** Show failures in the built-in alert. Turn off when the host shows `(failed)` itself. */
+  readonly showErrors: import("@angular/core").InputSignal<boolean>;
+  /** `'friendly'` (default), `'table'` (table text, else Stripe's own message: the cremo payment flows) or `'stripe'` (Stripe's own message). See `getStripeErrorMessage`. */
+  readonly errorDisplay: import("@angular/core").InputSignal<StripeErrorDisplay>;
+  /** Different error display for single steps (e.g. `{ submit: 'stripe', action: 'stripe' }`: raw Stripe text for the validation and 3DS steps, `errorDisplay` for the rest). */
+  readonly errorDisplayByStage: import("@angular/core").InputSignal<Partial<Record<StripeFailureStage, StripeErrorDisplay>> | null>;
+  /** The text when Stripe sends an error with no message (default: "Payment failed. Please try again."). */
+  readonly errorFallback: import("@angular/core").InputSignal<string>;
+  /** The same per step (Settings: `{ submit: 'Failed to submit payment information', confirm: 'Failed to confirm payment method' }`); wins over `errorFallback`. */
+  readonly errorFallbackByStage: import("@angular/core").InputSignal<Partial<Record<StripeFailureStage, string>> | null>;
+  /** Replacement texts by code: Stripe error codes AND the library's own failure codes (`not_initialized`, `no_payment_method`, `requires_payment_method`, `not_completed`, `authentication_failed`, ...). `{status}` in a text becomes Stripe's status of the intent ("Unexpected payment status: {status}"). */
+  readonly errorMessages: import("@angular/core").InputSignal<Record<string, string> | null>;
+  readonly loadErrorMessage: import("@angular/core").InputSignal<string>;
+  /** Texts of the screen-reader status region (translate them); missing keys keep the English defaults. */
+  readonly a11yMessages: import("@angular/core").InputSignal<Partial<StripeA11yMessages> | null>;
+  /**
+   * The live Stripe.js objects, emitted once each time the Elements are created: right after `elements.create('payment')` and `mount()` succeeded, before `(ready)`
+   * (the moment the old inline code had `this.stripe` / `this.elements` / `this.paymentElement` assigned). `null` is emitted when they go away (the form is re-created for new
+   * inputs, or `destroyElements()`): drop your references. Destroying the component itself emits nothing (the host owns that moment).
+   */
+  readonly stripeReady: import("@angular/core").OutputEmitterRef<StripeReadyEvent | null>;
+  /** The Payment Element finished loading. */
+  readonly ready: import("@angular/core").OutputEmitterRef<void>;
+  /** The customer picked another payment method type (`'card'`, `'us_bank_account'`, ...). */
+  readonly paymentMethodTypeChange: import("@angular/core").OutputEmitterRef<string>;
+  /** Every change of the form: completeness and the selected type. */
+  readonly elementChange: import("@angular/core").OutputEmitterRef<StripeElementChange>;
+  /** The intent was confirmed (succeeded, processing, needs bank verification, or needs a further action). */
+  readonly confirmed: import("@angular/core").OutputEmitterRef<StripeConfirmedEvent>;
+  /** A step failed (validation, intent creation, confirmation). `message` is ready to show. */
+  readonly failed: import("@angular/core").OutputEmitterRef<StripeFailure>;
+  /** Stripe.js or the Payment Element could not be loaded. */
+  readonly loadError: import("@angular/core").OutputEmitterRef<StripeFailure>;
+  readonly loading: import("@angular/core").WritableSignal<boolean>;
+  readonly isReady: import("@angular/core").WritableSignal<boolean>;
+  readonly submitting: import("@angular/core").WritableSignal<boolean>;
+  readonly complete: import("@angular/core").WritableSignal<boolean>;
+  /** The selected payment method type, `null` until Stripe reports one. */
+  readonly selectedType: import("@angular/core").WritableSignal<string | null>;
+  readonly errorText: import("@angular/core").WritableSignal<string>;
+  readonly loadErrorText: import("@angular/core").WritableSignal<string>;
+  private readonly announcement;
+  protected readonly errorId: string;
+  private readonly mountRef;
+  protected readonly mountHidden: import("@angular/core").Signal<boolean>;
+  protected readonly achNoticeVisible: import("@angular/core").Signal<boolean>;
+  protected readonly effectiveSubmitLabel: import("@angular/core").Signal<string>;
+  protected readonly submitDisabled: import("@angular/core").Signal<boolean>;
+  private readonly messages;
+  protected readonly statusText: import("@angular/core").Signal<string>;
+  /** How `loadStripe` is called: key + options. Re-creates everything when it changes. */
+  private readonly connection;
+  /** The `stripe.elements()` options without the deferred amount (that one is updated in place); `null` while there is no intent to show. */
+  private readonly elementsConfig;
+  /** The Payment Element options that need a new element when they change (default values and read-only are updated in place). */
+  private readonly elementConfig;
+  private stripe;
+  private stripeSignature;
+  private elements;
+  private element;
+  private generation;
+  private lastType;
+  private lastAmount;
+  private lastFailure;
+  private destroyed;
+  /** What the element was last given, so a change made while it loaded is applied once it is ready. */
+  private appliedDefaultValues;
+  private appliedDisabled;
+  constructor();
+  /**
+   * Submits the form: `elements.submit()` (when required), the deferred intent, then `confirmSetup` / `confirmPayment`.
+   * Resolves the normalised result (also emitted as `confirmed`), or `null` after a failure (emitted as `failed`) or when nothing was started
+   * (already submitting, or disabled). Never rejects: anything Stripe.js throws becomes a `failed` event.
+   *
+   * `useExistingIntent`: the intent already exists (a retry after a failed attempt, or one created earlier): no `elements.submit()`, no `createIntent`,
+   * and `confirmPayment` / `confirmSetup` is called WITHOUT a client secret, exactly like cremo's intake retry. Pass `clientSecret` (the one you stored) to send it.
+   */
+  confirm(options?: {
+    useExistingIntent?: boolean;
+    clientSecret?: string;
+  }): Promise<StripeConfirmedEvent | null>;
+  /**
+   * Runs `stripe.handleCardAction(clientSecret)` (3D Secure) for a payment that came back `requires_action`, and reports the result like `confirm()`.
+   * Use it when `autoHandleCardAction` is off and the host handles `outcome: 'requires_action'` itself.
+   */
+  handleNextAction(clientSecret: string): Promise<StripeConfirmedEvent | null>;
+  /**
+   * `elements.fetchUpdates()`: after your backend changed the amount of the intent this form was created with (cremo intake: fees differ per payment method),
+   * so the form shows the new amount. Resolves `null` when it worked, else the failure (returned only, not emitted: the host decides, cremo ignores it).
+   */
+  fetchUpdates(): Promise<StripeFailure | null>;
+  /** `elements.update(options)`: change the deferred amount, appearance or locale without re-creating the form. */
+  updateElements(options: Record<string, unknown>): void;
+  /** `paymentElement.update(options)`. */
+  updatePaymentElement(options: Record<string, unknown>): void;
+  /** Removes the Payment Element (host teardown on cancel). The component re-creates it when its inputs change. */
+  destroyElements(): void;
+  /** Verify a bank account with the two micro-deposit amounts / the descriptor code of a PaymentIntent (the public "verify your bank" page). */
+  verifyMicrodepositsForPayment(clientSecret: string, data: MicrodepositVerifyData): Promise<StripeMicrodepositResult>;
+  /** Same for a SetupIntent. */
+  verifyMicrodepositsForSetup(clientSecret: string, data: MicrodepositVerifyData): Promise<StripeMicrodepositResult>;
+  /**
+   * After Stripe redirected the customer back to `returnUrl`: retrieves the intent (client secret from the URL by default) and reports it like `confirm()`
+   * (`confirmed` for succeeded / processing / needs verification / needs action, `failed` otherwise). `{ event: null, failure: null }` when the URL has no intent.
+   */
+  handleReturn(options?: {
+    clientSecret?: string;
+    kind?: StripeIntentKind;
+    search?: string;
+  }): Promise<StripeReturnResult>;
+  private errorOptions;
+  /** Something Stripe.js threw (an IntegrationError, a network failure) as a failure, with the text chosen like any Stripe error. */
+  private thrownFailure;
+  private buildConfirmParams;
+  private fail;
+  private finish;
+  private announce;
+  private runCardAction;
+  private ensureStripe;
+  private verifyWith;
+  private disposeElements;
+  private loadFailed;
+  private init;
+  private applyDefaultValues;
+  private applyDisabled;
+  private onChange;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StripePaymentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StripePaymentComponent, "ui-stripe-payment", never, {
+    "mountOnly": {
+      "alias": "mountOnly";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "publishableKey": {
+      "alias": "publishableKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "clientSecret": {
+      "alias": "clientSecret";
+      "required": false;
+      "isSignal": true;
+    };
+    "deferred": {
+      "alias": "deferred";
+      "required": false;
+      "isSignal": true;
+    };
+    "createIntent": {
+      "alias": "createIntent";
+      "required": false;
+      "isSignal": true;
+    };
+    "stripeAccount": {
+      "alias": "stripeAccount";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "stripeOptions": {
+      "alias": "stripeOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "paymentMethodTypes": {
+      "alias": "paymentMethodTypes";
+      "required": false;
+      "isSignal": true;
+    };
+    "elementsOptions": {
+      "alias": "elementsOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "layout": {
+      "alias": "layout";
+      "required": false;
+      "isSignal": true;
+    };
+    "paymentMethodOrder": {
+      "alias": "paymentMethodOrder";
+      "required": false;
+      "isSignal": true;
+    };
+    "wallets": {
+      "alias": "wallets";
+      "required": false;
+      "isSignal": true;
+    };
+    "fields": {
+      "alias": "fields";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultValues": {
+      "alias": "defaultValues";
+      "required": false;
+      "isSignal": true;
+    };
+    "business": {
+      "alias": "business";
+      "required": false;
+      "isSignal": true;
+    };
+    "terms": {
+      "alias": "terms";
+      "required": false;
+      "isSignal": true;
+    };
+    "paymentElementOptions": {
+      "alias": "paymentElementOptions";
+      "required": false;
+      "isSignal": true;
+    };
+    "appearance": {
+      "alias": "appearance";
+      "required": false;
+      "isSignal": true;
+    };
+    "appearanceFromTokens": {
+      "alias": "appearanceFromTokens";
+      "required": false;
+      "isSignal": true;
+    };
+    "returnUrl": {
+      "alias": "returnUrl";
+      "required": false;
+      "isSignal": true;
+    };
+    "billingDetails": {
+      "alias": "billingDetails";
+      "required": false;
+      "isSignal": true;
+    };
+    "confirmParams": {
+      "alias": "confirmParams";
+      "required": false;
+      "isSignal": true;
+    };
+    "redirect": {
+      "alias": "redirect";
+      "required": false;
+      "isSignal": true;
+    };
+    "submitBeforeConfirm": {
+      "alias": "submitBeforeConfirm";
+      "required": false;
+      "isSignal": true;
+    };
+    "autoHandleCardAction": {
+      "alias": "autoHandleCardAction";
+      "required": false;
+      "isSignal": true;
+    };
+    "submitLabel": {
+      "alias": "submitLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "showSubmit": {
+      "alias": "showSubmit";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "pending": {
+      "alias": "pending";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "mountId": {
+      "alias": "mountId";
+      "required": false;
+      "isSignal": true;
+    };
+    "mountClass": {
+      "alias": "mountClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "showAchNotice": {
+      "alias": "showAchNotice";
+      "required": false;
+      "isSignal": true;
+    };
+    "achNotice": {
+      "alias": "achNotice";
+      "required": false;
+      "isSignal": true;
+    };
+    "achNoticeTestId": {
+      "alias": "achNoticeTestId";
+      "required": false;
+      "isSignal": true;
+    };
+    "initialPaymentMethodType": {
+      "alias": "initialPaymentMethodType";
+      "required": false;
+      "isSignal": true;
+    };
+    "showErrors": {
+      "alias": "showErrors";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorDisplay": {
+      "alias": "errorDisplay";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorDisplayByStage": {
+      "alias": "errorDisplayByStage";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorFallback": {
+      "alias": "errorFallback";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorFallbackByStage": {
+      "alias": "errorFallbackByStage";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorMessages": {
+      "alias": "errorMessages";
+      "required": false;
+      "isSignal": true;
+    };
+    "loadErrorMessage": {
+      "alias": "loadErrorMessage";
+      "required": false;
+      "isSignal": true;
+    };
+    "a11yMessages": {
+      "alias": "a11yMessages";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "stripeReady": "stripeReady";
+    "ready": "ready";
+    "paymentMethodTypeChange": "paymentMethodTypeChange";
+    "elementChange": "elementChange";
+    "confirmed": "confirmed";
+    "failed": "failed";
+    "loadError": "loadError";
+  }, never, never, true, never>;
+}
+/** How a bank account added with micro-deposits is verified: two deposit amounts, the code of one deposit, or the bank is still confirming it. */
+type MicrodepositType = 'amounts' | 'descriptor_code' | 'processing';
+/** The text of the pending-verification card, in one place for the component and its tests. */
+export declare const MICRODEPOSIT_COPY: {
+  readonly title: "Bank account waiting for verification";
+  readonly processingTitle: "Bank account being confirmed";
+  readonly processing: "Your bank is confirming this account; this usually takes up to a few business days. We will email you when it is ready.";
+  readonly cannotPay: "Until then this account can't be used to pay invoices.";
+  readonly readOnly: "An administrator of your organization can finish the verification.";
+  readonly keepsActive: "Your current payment method stays active until the new bank account is verified.";
+  readonly cancelTitle: "Cancel verification";
+  readonly verifyLabel: "Verify bank account";
+  readonly cancelBase: "Cancel the verification of this bank account? It will not be saved as a payment method and you can add it again later.";
+  readonly cancelKeepsActive: " Your current payment method stays active.";
+  readonly cancelNoOther: " You have no other payment method saved.";
+  readonly tooManyAttempts: "Too many failed attempts. Please try again later or contact support.";
+  readonly codeRequired: "Enter the 6-character code.";
+};
+/** "June 5, 2026" in UTC: the arrival date is a calendar day. Empty for no / an invalid date. */
+export declare function microdepositArrivalText(iso: string | null | undefined): string;
+/** Amounts: two whole numbers of cents from 1 to 99 (Stripe's micro-deposits are 1 to 99 cents). Empty text = nothing to say yet. */
+export declare function depositAmountError(value: unknown): string;
+/** The code as sent to Stripe: trimmed, upper case. */
+export declare const normalizeDescriptorCode: (value: string | null | undefined) => string;
+/** The descriptor code: 6 letters or numbers; with `requireSmPrefix` (Stripe's codes look like SMXXXX) it must start with "SM". Empty = nothing to say yet. */
+export declare function descriptorCodeError(value: string | null | undefined, requireSmPrefix?: boolean): string;
+/** Only an https link is offered as Stripe's hosted verification page. */
+declare function safeHostedUrl(url: string | null | undefined): string | null;
+/** What `(verify)` emits: the two amounts in cents, or the code. */
+type MicrodepositVerifyEvent = {
+  amounts: [number, number];
+} | {
+  descriptorCode: string;
+};
+/** Who started a pending verification, from the point of view of the user looking at it (a partner page): this user, the partner, or somebody else. */
+type MicrodepositStartedBy = 'you' | 'partner' | 'other' | '';
+interface MicrodepositStepsContext {
+  type: Exclude<MicrodepositType, 'processing'>;
+  /** ISO timestamp of the day the deposits should arrive. */
+  arrivalDate?: string | null;
+  /** Set when the user looks at ANOTHER party's account (a crematory looking at a partner): "{partner}'s account", "Ask {partner} for ...". */
+  partnerName?: string;
+  /** The user cannot finish it (no form on the card). */
+  readOnly?: boolean;
+  /** Read-only: who started it. */
+  startedBy?: MicrodepositStartedBy;
+  /** Read-only: replaces ONLY the middle sentence ("An administrator of your organization can finish the verification." by default). */
+  readOnlyText?: string;
+}
+/**
+ * The explanation under the bank account: the deposits clause, then what to do (or, with no form, who can finish it), then
+ * "Until then this account can't be used to pay invoices." The exact strings of the cremo Settings / Partners cards.
+ */
+export declare function microdepositStepsText(ctx: MicrodepositStepsContext): string;
+/** While the bank is still confirming the account. */
+export declare function microdepositProcessingText(partnerName?: string): string;
+/** The note under the steps when a payment method is already saved. */
+export declare function microdepositKeepsActiveText(partnerName?: string): string;
+/** The message of the cancel confirm: the saved method stays active only when one is saved. */
+export declare function microdepositCancelMessage(options?: {
+  partnerName?: string;
+  hasSavedMethod?: boolean;
+}): string;
+/**
+ * "Bank account waiting for verification": explains the steps in plain words, takes the two deposit amounts (or the 6-character code),
+ * links to Stripe's own verification page, and lets the user cancel. Read-only users see the card but no form and no buttons.
+ *
+ * Two ways to verify, same screen:
+ * - Host verifies (default): `(verify)` emits `{ amounts: [a, b] }` or `{ descriptorCode }`; the host calls its backend and shows
+ *   `[verifying]` / `[errorText]` (your API owns the rules and the attempts).
+ * - Stripe.js verifies (public "verify your bank" page): pass `[clientSecret]` (+ `[publishableKey]`, `[stripeAccount]`, `[flow]`); the component calls
+ *   `verifyMicrodepositsForPayment/Setup` itself, counts failed attempts (`[maxAttempts]`) and emits `(verified)`.
+ *
+ *   <ui-microdeposit-verify type="amounts" bankName="Chase" last4="6789" arrivalDate="2026-06-05T00:00:00Z"
+ *     [verifying]="busy()" [errorText]="error()" (verify)="verify($event)" (cancelVerification)="cancel()" />
+ */
+export declare class MicrodepositVerifyComponent {
+  private readonly service;
+  /** `'amounts'` (two deposits), `'descriptor_code'` (one deposit with a code) or `'processing'` (the bank is still confirming; nothing to enter). */
+  readonly type: import("@angular/core").InputSignal<MicrodepositType>;
+  readonly bankName: import("@angular/core").InputSignal<string>;
+  readonly last4: import("@angular/core").InputSignal<string>;
+  /** The day the deposits should have arrived (ISO timestamp); empty when unknown. See `StripeVerification.arrivalDateIso`. */
+  readonly arrivalDate: import("@angular/core").InputSignal<string | null>;
+  /** Stripe's own verification page; only an https link is shown. */
+  readonly hostedVerificationUrl: import("@angular/core").InputSignal<string | null>;
+  /** Read-only users see the card with `readOnlyText` but no form, link or buttons. */
+  readonly readOnly: import("@angular/core").InputSignal<boolean>;
+  /** Show the card as plain status: no form, link or buttons, and the steps text is yours (`stepsText`). For a page where someone else finishes the verification. */
+  readonly statusOnly: import("@angular/core").InputSignal<boolean>;
+  /** Replaces the card heading (default: "Bank account waiting for verification" / "Bank account being confirmed"). */
+  readonly title: import("@angular/core").InputSignal<string>;
+  /** Replaces the whole steps text (the sentences about the deposits and what to enter). Use it for wording the library cannot know (a partner's name, who started it). */
+  readonly stepsText: import("@angular/core").InputSignal<string>;
+  /** Read-only / status-only: replaces ONLY the middle sentence of the steps text (the deposits clause before it and "Until then this account can't be used ..." after it stay). */
+  readonly readOnlyText: import("@angular/core").InputSignal<string>;
+  /** Hide Stripe's hosted-page link even for users who could use it. */
+  readonly hideHostedLink: import("@angular/core").InputSignal<boolean>;
+  readonly cancelLabel: import("@angular/core").InputSignal<string>;
+  readonly verifyLabel: import("@angular/core").InputSignal<string>;
+  /** Replaces "Your current payment method stays active until the new bank account is verified." */
+  readonly keepsActiveText: import("@angular/core").InputSignal<string>;
+  /** Replaces the cancel confirm's message. */
+  readonly cancelMessageText: import("@angular/core").InputSignal<string>;
+  /** A payment method is already saved (it stays active until the new bank account is verified). */
+  readonly hasSavedMethod: import("@angular/core").InputSignal<boolean>;
+  /** Host mode: the host's verify request is running. */
+  readonly verifying: import("@angular/core").InputSignal<boolean>;
+  /** Host mode: the host's cancel request is running. */
+  readonly cancelling: import("@angular/core").InputSignal<boolean>;
+  /** Host mode: the verification failed; shown above the button. */
+  readonly errorText: import("@angular/core").InputSignal<string>;
+  /** Offer "Cancel verification" (with its confirm). */
+  readonly allowCancel: import("@angular/core").InputSignal<boolean>;
+  /** Descriptor codes must look like Stripe's (`SMXXXX`). */
+  readonly requireSmPrefix: import("@angular/core").InputSignal<boolean>;
+  readonly clientSecret: import("@angular/core").InputSignal<string | null>;
+  readonly publishableKey: import("@angular/core").InputSignal<string | null>;
+  readonly stripeAccount: import("@angular/core").InputSignal<string | null>;
+  /** Which kind of intent `clientSecret` belongs to. */
+  readonly flow: import("@angular/core").InputSignal<StripeIntentKind>;
+  /** Stripe.js mode: stop sending after this many failed attempts (0 = no limit here). */
+  readonly maxAttempts: import("@angular/core").InputSignal<number>;
+  /** Host mode: the amounts / code to verify. */
+  readonly verify$: import("@angular/core").OutputEmitterRef<MicrodepositVerifyEvent>;
+  /** The user confirmed cancelling the verification. */
+  readonly cancelVerification: import("@angular/core").OutputEmitterRef<void>;
+  /** Stripe.js mode: the bank account is verified. */
+  readonly verified: import("@angular/core").OutputEmitterRef<StripeMicrodepositResult>;
+  /** Stripe.js mode: a verification attempt failed (the text is already shown). */
+  readonly verifyFailed: import("@angular/core").OutputEmitterRef<StripeMicrodepositResult>;
+  readonly copy: {
+    readonly title: "Bank account waiting for verification";
+    readonly processingTitle: "Bank account being confirmed";
+    readonly processing: "Your bank is confirming this account; this usually takes up to a few business days. We will email you when it is ready.";
+    readonly cannotPay: "Until then this account can't be used to pay invoices.";
+    readonly readOnly: "An administrator of your organization can finish the verification.";
+    readonly keepsActive: "Your current payment method stays active until the new bank account is verified.";
+    readonly cancelTitle: "Cancel verification";
+    readonly verifyLabel: "Verify bank account";
+    readonly cancelBase: "Cancel the verification of this bank account? It will not be saved as a payment method and you can add it again later.";
+    readonly cancelKeepsActive: " Your current payment method stays active.";
+    readonly cancelNoOther: " You have no other payment method saved.";
+    readonly tooManyAttempts: "Too many failed attempts. Please try again later or contact support.";
+    readonly codeRequired: "Enter the 6-character code.";
+  };
+  readonly first: import("@angular/core").WritableSignal<string | number>;
+  readonly second: import("@angular/core").WritableSignal<string | number>;
+  readonly code: import("@angular/core").WritableSignal<string>;
+  readonly touched: import("@angular/core").WritableSignal<boolean>;
+  readonly showCancelConfirm: import("@angular/core").WritableSignal<boolean>;
+  private readonly stripeBusy;
+  private readonly stripeError;
+  private failedAttempts;
+  readonly formHidden: import("@angular/core").Signal<boolean>;
+  readonly heading: import("@angular/core").Signal<string>;
+  /** "Chase ····6789"; nothing when neither the bank nor the last 4 digits are known. */
+  readonly bankLine: import("@angular/core").Signal<string>;
+  readonly busy: import("@angular/core").Signal<boolean>;
+  readonly shownError: import("@angular/core").Signal<string>;
+  readonly isProcessing: import("@angular/core").Signal<boolean>;
+  readonly safeUrl: import("@angular/core").Signal<string | null>;
+  /** The built-in steps text: deposits clause + what to do, or with no form the `readOnlyText` sentence, + "Until then this account can't be used to pay invoices." */
+  readonly defaultSteps: import("@angular/core").Signal<string>;
+  readonly amountError: typeof depositAmountError;
+  readonly codeError: import("@angular/core").Signal<string>;
+  readonly hasInvalid: import("@angular/core").Signal<boolean>;
+  /** The cancel confirm tells the truth: the saved method stays active only when one is saved. */
+  readonly cancelMessage: import("@angular/core").Signal<string>;
+  verify(): Promise<void>;
+  confirmCancel(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MicrodepositVerifyComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MicrodepositVerifyComponent, "ui-microdeposit-verify", never, {
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "bankName": {
+      "alias": "bankName";
+      "required": false;
+      "isSignal": true;
+    };
+    "last4": {
+      "alias": "last4";
+      "required": false;
+      "isSignal": true;
+    };
+    "arrivalDate": {
+      "alias": "arrivalDate";
+      "required": false;
+      "isSignal": true;
+    };
+    "hostedVerificationUrl": {
+      "alias": "hostedVerificationUrl";
+      "required": false;
+      "isSignal": true;
+    };
+    "readOnly": {
+      "alias": "readOnly";
+      "required": false;
+      "isSignal": true;
+    };
+    "statusOnly": {
+      "alias": "statusOnly";
+      "required": false;
+      "isSignal": true;
+    };
+    "title": {
+      "alias": "title";
+      "required": false;
+      "isSignal": true;
+    };
+    "stepsText": {
+      "alias": "stepsText";
+      "required": false;
+      "isSignal": true;
+    };
+    "readOnlyText": {
+      "alias": "readOnlyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "hideHostedLink": {
+      "alias": "hideHostedLink";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelLabel": {
+      "alias": "cancelLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "verifyLabel": {
+      "alias": "verifyLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "keepsActiveText": {
+      "alias": "keepsActiveText";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelMessageText": {
+      "alias": "cancelMessageText";
+      "required": false;
+      "isSignal": true;
+    };
+    "hasSavedMethod": {
+      "alias": "hasSavedMethod";
+      "required": false;
+      "isSignal": true;
+    };
+    "verifying": {
+      "alias": "verifying";
+      "required": false;
+      "isSignal": true;
+    };
+    "cancelling": {
+      "alias": "cancelling";
+      "required": false;
+      "isSignal": true;
+    };
+    "errorText": {
+      "alias": "errorText";
+      "required": false;
+      "isSignal": true;
+    };
+    "allowCancel": {
+      "alias": "allowCancel";
+      "required": false;
+      "isSignal": true;
+    };
+    "requireSmPrefix": {
+      "alias": "requireSmPrefix";
+      "required": false;
+      "isSignal": true;
+    };
+    "clientSecret": {
+      "alias": "clientSecret";
+      "required": false;
+      "isSignal": true;
+    };
+    "publishableKey": {
+      "alias": "publishableKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "stripeAccount": {
+      "alias": "stripeAccount";
+      "required": false;
+      "isSignal": true;
+    };
+    "flow": {
+      "alias": "flow";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxAttempts": {
+      "alias": "maxAttempts";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "verify$": "verify";
+    "cancelVerification": "cancelVerification";
+    "verified": "verified";
+    "verifyFailed": "verifyFailed";
+  }, 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 };