@flopay/js 1.4.23 → 1.4.24

package/dist/card-setup-B8II-Etg.d.cts

@@ -0,0 +1,589 @@
+import { CheckoutSessionMode, CheckoutGateways, VaultCaptureBlock, NormalizedCheckoutSession, ProcessPaymentParams, CreateSessionIntentRequest, SessionIntent, SessionIntentDeclineRequest, InlineSessionDraft, DetachedCheckoutSession, CardCaptureAdapter, CardCaptureProviderId, CaptureMethod, CardCaptureMountOptions, CardCaptureEventType, CardCaptureOutcomeEvent, VaultCardThemeColors, VaultCardFieldKey } from '@flopay/shared';
+
+/**
+ * Client-side cache for display-only checkout fields the backend no longer
+ * persists (`overrideAmount`, `totalAmount`, `providerItemName`,
+ * `providerPlanName`, per-line `currency`).
+ *
+ * The cache lives in `sessionStorage` so it survives the navigation from the
+ * page that creates the session to the checkout page that fetches it, but
+ * dies on tab close. An in-memory fallback keeps the SDK working in Node /
+ * SSR contexts where `sessionStorage` is unavailable.
+ *
+ * Values from the server response always win — cached values fill in only
+ * where the server returned `null` or `undefined`.
+ */
+/** Display-only fields per product that can be cached and merged back later. */
+interface SessionDisplayProduct {
+    /** Catalog code (match key). */
+    code?: string;
+    /** Whether this product is a one-time item or a recurring subscription. */
+    type?: 'item' | 'subscription';
+    /** Display-only name for the product. */
+    name?: string | null;
+    totalAmount?: number;
+    overrideAmount?: number | null;
+    currency?: string;
+}
+/** Display-only payload that can be stashed for later merge into a session response. */
+interface SessionDisplayCacheData {
+    /** Session-level currency (falls into the response only when the server omits it). */
+    currency?: string;
+    products?: SessionDisplayProduct[];
+}
+/**
+ * Stash display-only data for a session. Called client-side right after the
+ * server returns a session ID, so the values survive the redirect to the
+ * checkout page.
+ */
+declare function cacheSessionDisplayData(sessionId: string, data: SessionDisplayCacheData, options?: {
+    ttlMs?: number;
+}): void;
+/**
+ * Read previously-cached display data for a session, or `null` if nothing
+ * is cached (or the TTL has elapsed).
+ */
+declare function getSessionDisplayData(sessionId: string): SessionDisplayCacheData | null;
+/**
+ * Drop any cached display data for a session. Call from the success page
+ * after the payment completes; otherwise the TTL handles cleanup.
+ */
+declare function clearSessionDisplayData(sessionId: string): void;
+
+/** Raw billing API response wrapper. */
+interface BillingResponse<T> {
+    data: T;
+}
+/** Raw checkout session from the billing API. */
+interface RawCheckoutSession {
+    uuid: string;
+    nonce: string;
+    status: 'pending' | 'authorized' | 'completed' | 'expired';
+    successUrl: string;
+    cancelUrl: string;
+    /** Session-level currency. */
+    currency?: string;
+    createdAt?: string;
+    checkoutUrl?: string;
+    /** Unified products list returned by the billing API (post-#760). */
+    products?: Array<{
+        uuid: string;
+        checkoutSessionId: string;
+        /** 'item' or 'subscription'. */
+        type: 'item' | 'subscription';
+        code?: string;
+        name?: string | null;
+        description?: string | null;
+        quantity: number;
+        totalAmount?: number;
+        overrideAmount?: number | null;
+        currency?: string;
+        metadata?: Record<string, unknown> | null;
+    }>;
+    coupons?: string[];
+    /**
+     * Pre-discount total in cart-currency major units. Populated by billing
+     * API ≥ v1.1.2; absent on older backends.
+     */
+    subtotalAmount?: number;
+    /** Total reduction from applied coupons (cart-currency major units). */
+    discountAmount?: number;
+    /** Final charge amount after coupon discount (cart-currency major units). */
+    totalAmount?: number;
+    checkoutMode?: CheckoutSessionMode;
+    captureMethod?: 'automatic' | 'manual';
+    paymentId?: string;
+    authorizationExpiresAt?: string;
+    /** Backend authorization/capture lifecycle reason, normalized before exposure. */
+    failureReason?: string;
+    outcome?: string;
+    gateways?: CheckoutGateways;
+    /**
+     * Generic downstream card-method id for a card already on file
+     * (TeamFloPay/backend#823) — present for returning customers so the SDK can
+     * skip the vault widget. Absent for first-time buyers.
+     */
+    providerPaymentMethodId?: string | null;
+    accountData: {
+        userId: string;
+        firstName: string;
+        lastName: string;
+        email: string;
+        gender?: string | null;
+        city?: string | null;
+        state?: string | null;
+        country?: string | null;
+        zip?: string | null;
+        addressLine1?: string | null;
+        addressLine2?: string | null;
+    };
+    tagsData: {
+        googleContainerId?: string | null;
+        sessionId?: string | null;
+        testEventCode?: string | null;
+    };
+}
+type AccountSnapshotTelemetryMode = 'blocking' | 'best_effort';
+interface PaymentAPIOptions {
+    /** Flo-owned privacy-safe telemetry is enabled by default; set false to opt out. */
+    telemetry?: boolean;
+}
+declare const SESSION_CREATE_TELEMETRY: unique symbol;
+/**
+ * Client-side payment API service.
+ *
+ * Mirrors the `PaymentAPI` class from the checkout project's
+ * `src/service/api.ts`. All methods call the billing API endpoints
+ * that the checkout backend exposes.
+ */
+declare class PaymentAPI {
+    private static readonly activeVaultCaptureRequests;
+    private readonly baseUrl;
+    private readonly directTelemetry?;
+    private readonly telemetryHooks?;
+    private directTelemetryCheckoutId?;
+    constructor(billingApiUrl: string, options?: PaymentAPIOptions);
+    /** Dispose the reporter owned by direct public usage. Internal hooks are never disposed here. */
+    destroy(): void;
+    private reportDirectFailure;
+    /**
+     * A hosted-vault snapshot timeout is an observed fallback, not a checkout
+     * failure: the widget charge is already proceeding with the session baseline.
+     * Every other snapshot failure and every default/direct timeout remains an
+     * alert-level technical error.
+     */
+    private reportAccountSnapshotFailure;
+    private telemetryTimestamp;
+    private beginDirectTelemetryCheckout;
+    private beginDirectTelemetryOperation;
+    private adoptDirectTelemetryCheckout;
+    /**
+     * Fetch a raw checkout session by ID.
+     *
+     * `nonce` is the session-bound checkout token returned when the session
+     * was created. When supplied it is sent as the `x-checkout-session-token`
+     * header that post-#640 backends match against `checkout_session.nonce`
+     * before returning the row — the UUID alone is no longer sufficient.
+     * Backends that don't yet enforce it ignore the extra header.
+     */
+    getCheckoutSession(checkoutSessionId: string, nonce?: string): Promise<BillingResponse<RawCheckoutSession>>;
+    /**
+     * Stash display-only data for a session so subsequent fetches can fill in
+     * fields the backend no longer persists (`overrideAmount`, `totalAmount`,
+     * `providerItemName`, `providerPlanName`).
+     *
+     * Backed by `sessionStorage` in the browser, with an in-memory fallback in
+     * Node/SSR contexts. Default TTL: 1 hour.
+     *
+     * Server-returned values always win — cached values fill in only where the
+     * server returned `null` / `undefined`.
+     *
+     * @example
+     * ```ts
+     * paymentAPI.cacheSessionDisplayData(sessionId, {
+     *   currency: 'USD',
+     *   items: [{ code: 'pro_plan', overrideAmount: 24.99, providerItemName: 'Pro' }],
+     * });
+     * ```
+     */
+    cacheSessionDisplayData(sessionId: string, data: SessionDisplayCacheData, options?: {
+        ttlMs?: number;
+    }): void;
+    /**
+     * Drop any cached display data for a session. Call after the payment
+     * completes; otherwise the TTL handles cleanup.
+     */
+    clearSessionDisplayData(sessionId: string): void;
+    /**
+     * Fetch (re-mint) the hosted vault capture widget for a session
+     * (TeamFloPay/backend#823).
+     *
+     * `POST /v1/checkouts/sessions/{id}/vault/capture` returns the SDK-ready
+     * {@link VaultCaptureBlock} (`html` + `url`, plus `messageToken` /
+     * `expectedOrigin` once the backend mints them). The SDK injects `html` as
+     * the card-capture widget. This is the lazy path for explicitly card-capable
+     * sessions that do not receive an embedded `vault` block; the endpoint is
+     * idempotent and reuses session-cached creds when available.
+     *
+     * Because the endpoint is idempotent, transient network failures receive a
+     * bounded retry and a stalled request aborts after ten seconds. Concurrent
+     * callers for the same base URL, session, and nonce share the active promise,
+     * preventing React renders/remounts from racing competing recovery POSTs.
+     *
+     * The PCIVault submit *secret* the backend may include in the response is
+     * intentionally **not** read or surfaced — it is server-only and never enters
+     * the SDK runtime.
+     *
+     * `nonce` is forwarded as `x-checkout-session-token` (required by post-#640
+     * backends, matched against the session's stored nonce).
+     */
+    getVaultCapture(checkoutSessionId: string, nonce?: string): Promise<VaultCaptureBlock>;
+    private requestVaultCapture;
+    /**
+     * Fetch and normalize a checkout session.
+     *
+     * Reads the backend's `gateways` map to enumerate provider-specific data,
+     * then wraps the session in a `NormalizedCheckoutSession` for provider-
+     * agnostic consumption.
+     */
+    getUnifiedCheckoutSession(checkoutSessionId: string, nonce?: string): Promise<NormalizedCheckoutSession>;
+    /**
+     * Submit a tokenized payment to the billing backend.
+     *
+     * The backend will either succeed, return `type: '3ds_required'`
+     * (with a `threeDSecureToken`), or return `type: 'paypal_redirect_required'`.
+     *
+     * Hits the session-scoped route `POST /v1/checkouts/sessions/:id/process`
+     * and forwards `data.nonce` as `x-checkout-session-token`. Backend
+     * `TeamFloPay/backend#640` rejects callers without a matching nonce with a
+     * 401 — this method throws synchronously when `data.nonce` is missing so the
+     * problem surfaces before the network round trip.
+     *
+     * @param userId Vestigial — backend's GatewayInterceptor routes via session,
+     *   not headers, so this value is no longer sent on the wire. Kept in the
+     *   signature for back-compat with existing callers; will be removed in a
+     *   future major version.
+     */
+    processPayment(_userId: string, data: ProcessPaymentParams, options?: {
+        pollTimeoutMs?: number;
+    }): Promise<Response>;
+    /**
+     * Patch the buyer's account snapshot (email, name, billing address, AVS
+     * intent) onto a checkout session via
+     * `PATCH /v1/checkouts/sessions/{id}/account` (TeamFloPay/backend#823).
+     *
+     * The vault path's hosted form owns the charge end-to-end so the SDK
+     * never calls `/process` on this path; the buyer-typed AVS / billing
+     * address would otherwise be lost. The SDK calls this just before
+     * submitting the vault widget so the downstream listener mints the
+     * Stripe PaymentMethod with the right `billing_details.address` and the
+     * per-attempt + per-PM address snapshots are populated.
+     *
+     * Body shape mirrors the relevant subset of `/process`'s
+     * `ProcessCheckoutBodyDto` — same keys, same validators. The endpoint
+     * is idempotent: empty/undefined fields are not written, addresses are
+     * last-writer-wins, AVS analytics are first-writer-wins.
+     *
+     * Wrapped in `fetchWithNetworkRetry` because a transient blip on this
+     * pre-pay PATCH would silently leave AVS unsent and cause an
+     * AVS-protected charge to decline downstream.
+     */
+    patchAccountSnapshot(sessionId: string, nonce: string, body: {
+        accountData: {
+            userId: string;
+            email: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            addressLine1?: string | null;
+            addressLine2?: string | null;
+            city?: string | null;
+            state?: string | null;
+            zip?: string | null;
+            country?: string | null;
+            gender?: string | null;
+        };
+        avsCheck?: boolean;
+        avsConfig?: Record<string, unknown>;
+    }, options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+        /**
+         * Downgrade only a timeout to `operation.fallback` when the caller can
+         * continue safely. The promise still rejects and all other failures stay
+         * technical errors. Defaults to `blocking`.
+         */
+        telemetryMode?: AccountSnapshotTelemetryMode;
+    }): Promise<void>;
+    /** Create a wallet/APM/PayPal intent through the session-scoped contract. */
+    createSessionIntent(sessionId: string, nonce: string, request: CreateSessionIntentRequest, options?: {
+        signal?: AbortSignal;
+        idempotencyKey?: string;
+    }): Promise<SessionIntent>;
+    /** Record a provider-neutral non-card decline without sensitive identifiers. */
+    reportSessionIntentDecline(sessionId: string, nonce: string, request: SessionIntentDeclineRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Fetch user's prior payments by email.
+     * Used to determine if saved card UX should be shown.
+     */
+    getPaymentsByEmail(email: string, options?: {
+        signal?: AbortSignal;
+        page?: number;
+        limit?: number;
+    }): Promise<{
+        data: Array<{
+            id: string;
+        }>;
+        total: number;
+        page: number;
+        limit: number;
+    }>;
+    /**
+     * Create a checkout session AND return the full session data in one call.
+     * Uses `?expand=true` so the backend returns the complete session
+     * instead of just a UUID — eliminating the need for a second GET.
+     *
+     * Falls back to create + GET if the backend doesn't support `expand`.
+     *
+     * Eligible sessions are created through the **detached** shell + claim flow
+     * (see {@link PaymentAPI.createDetachedSession}) and this method awaits the
+     * claim, so its resolved value is unchanged — callers still receive one
+     * fully-populated session. The win here is server-side: the create no longer
+     * contends on buyer-identity advisory locks. Callers that want to render from
+     * the shell *before* the claim lands — mounting the card form early — should
+     * call {@link PaymentAPI.createDetachedSession} directly. Pass
+     * `deferDataAttachment: false` to force the original one-shot create.
+     */
+    createAndFetchSession(params: InlineSessionDraft): Promise<NormalizedCheckoutSession>;
+    private createAndFetchSessionRequest;
+    /**
+     * `POST /v1/checkouts/sessions` with the SDK's bounded retry budget.
+     *
+     * Network failures and the backend's documented in-progress replay share one
+     * attempt budget and one operation-wide abort signal, so the two retry modes
+     * cannot multiply into nine POSTs during an outage. The idempotency key is
+     * resolved once, before the loop — an invalid merchant-supplied key throws
+     * before any request, and every attempt of this logical create replays the
+     * same key so a timeout cannot mint a second session
+     * (TeamFloPay/backend#972).
+     */
+    private postCheckoutSessionCreate;
+    /**
+     * Create a checkout session **detached** from its buyer and catalog data
+     * (TeamFloPay/backend#1099).
+     *
+     * Resolves as soon as the lightweight *shell* exists. That create runs no
+     * catalog validation and takes none of the buyer-identity advisory locks that
+     * serialise concurrent checkouts for the same customer, and the backend routes
+     * a gateway for it from `currency` + the buyer's country — so the shell
+     * already carries the session id, nonce, `gateways` and the hosted `vault`
+     * block. The card form can mount from it immediately.
+     *
+     * Buyer identity, address, products and coupons are attached by the returned
+     * {@link DetachedCheckoutSession.claimed} promise, which is already in flight
+     * when this resolves. **Nothing may be charged until it settles** — the
+     * billing API rejects process / intent / decline calls on an unclaimed
+     * session with `409 checkout_session_data_attachment_required`, and holds an
+     * unclaimed vault charge with a retryable `503`.
+     *
+     * Requires a billing API with `PATCH /v1/checkouts/sessions/{id}/claim`; there
+     * is no fallback to the one-shot create. Callers that want the original
+     * single-request behaviour should pass `deferDataAttachment: false` and use
+     * {@link PaymentAPI.createAndFetchSession}.
+     */
+    createDetachedSession(params: InlineSessionDraft): Promise<DetachedCheckoutSession>;
+    /**
+     * `PATCH /v1/checkouts/sessions/{id}/claim` — attach buyer identity, address,
+     * products and coupons to a detached session shell.
+     *
+     * The backend fingerprints the payload, so a transport retry replaying the
+     * identical body returns the same claimed session rather than conflicting; a
+     * *materially different* claim for an already-claimed session returns `409`,
+     * which is surfaced without retrying. Invalid catalog data surfaces here as
+     * the same `422` the one-shot create would have returned — later in the flow,
+     * but with identical semantics.
+     */
+    claimCheckoutSession(checkoutSessionId: string, nonce: string, payload: Record<string, unknown>, internal?: {
+        params: InlineSessionDraft;
+        startedAt: number;
+        deadline: {
+            signal: AbortSignal;
+            clear(): void;
+        };
+        /**
+         * Attempts the shell create needed. The `session_create` rollup below
+         * reports this rather than the claim's own attempt count, so an
+         * end-to-end span keeps meaning "attempts to create this session".
+         */
+        createAttempt: number;
+    }): Promise<NormalizedCheckoutSession>;
+    /** Shared create/claim failure reporting so both phases classify identically. */
+    private reportSessionCreateFailure;
+    waitForCheckoutSessionCompletion(checkoutSessionId: string, options?: {
+        initialDelayMs?: number;
+        timeoutMs?: number;
+        /**
+         * Session-bound checkout token; forwarded on the poll's
+         * `GET /v1/checkouts/sessions/:id`. Required by post-#640 backends.
+         */
+        nonce?: string;
+    }): Promise<NormalizedCheckoutSession>;
+    /** Normalize a raw session into a provider-agnostic shape. */
+    private normalizeRawSession;
+    /** Convert raw session to the SDK CheckoutSession shape. */
+    private toCheckoutSession;
+    /**
+     * Coerce a raw vault block into a typed {@link VaultCaptureBlock}. The
+     * server-only PCIVault submit `secret` is deliberately dropped so it never
+     * lands on the public session surface (logs / telemetry / client inspection).
+     */
+    private toVaultBlock;
+    private toCheckoutSessionStatus;
+    private resolveProcessResponse;
+    private toCheckoutProcessingPending;
+    private clampRetryAfterMs;
+    /**
+     * Stash the display-only fields the consumer passed into a create-session
+     * call. Runs after the backend assigns a UUID so a later GET on the same
+     * session (typically after a redirect) can fill in fields the backend no
+     * longer persists — `overrideAmount`, `totalAmount`, `name`, etc.
+     *
+     * No-op when no UUID is available.
+     */
+    private autoCacheDisplayData;
+    /**
+     * Merge cached display-only fields (set by {@link cacheSessionDisplayData})
+     * into a raw session response. Server values always win — cache fills in
+     * only where the server returned `null` / `undefined`.
+     */
+    private mergeCachedDisplayData;
+}
+
+/** Browser operation hosted by the PCIVault card-capture adapter. */
+type CardCaptureOperation = 'checkout' | 'card_setup';
+/** Configuration for a {@link PciVaultCardCapture} instance. */
+interface PciVaultCardCaptureConfig {
+    /** Checkout session id bound to the capture (for outcome correlation + trust). */
+    sessionId?: string;
+    /** Capture behavior of the checkout session, used to classify legacy outcomes safely. */
+    captureMethod?: CaptureMethod;
+    /** Distinguishes no-charge card verification telemetry from checkout payment telemetry. */
+    operation?: CardCaptureOperation;
+    /**
+     * Default strict origin for vault `postMessage` outcomes. Overridden by
+     * {@link CardCaptureMountOptions.expectedOrigin} when that is supplied at
+     * mount. When neither is set the origin gate is skipped (the widget posts
+     * same-window in the Model-A flow).
+     */
+    expectedOrigin?: string;
+    /** Flo-owned privacy-safe telemetry is enabled by default; set false to opt out. */
+    telemetry?: boolean;
+}
+/**
+ * {@link CardCaptureAdapter} backed by the backend-rendered PCIVault hosted
+ * widget.
+ *
+ * `mount()` injects the server-supplied widget HTML (re-executing its bundled
+ * `<script>` so the form bootstraps) and subscribes to the widget's
+ * `postMessage` outcome. The backend owns everything else; this adapter never
+ * touches the card data, a payment intent, or 3DS.
+ */
+declare class PciVaultCardCapture implements CardCaptureAdapter {
+    readonly provider: CardCaptureProviderId;
+    private readonly config;
+    private telemetryReporter?;
+    /** Reporter already initialized for this adapter's setup operation. */
+    private setupTelemetryReporter?;
+    private readonly ownsTelemetryReporter;
+    private container;
+    private messageHandler;
+    /**
+     * Parent-page-level overlay rendering the provider's verification challenge
+     * (3DS-2 iframe) on `action_required`. Owned by the adapter — not the
+     * widget — so it can sit above the host SDK's processing backdrop, which
+     * would otherwise visually cover an in-widget challenge iframe.
+     */
+    private actionOverlay;
+    /**
+     * Listener that catches the `flopay-vault-3ds-return` postMessage from the
+     * provider's challenge return page. When the SDK owns the challenge iframe
+     * the return page lives inside *that* iframe (not the widget's), so
+     * `window.parent` is the host page — the widget's existing message
+     * listener can't see it. The SDK forwards completion into the widget via
+     * `action_completed` so the widget kicks `/3ds/complete` immediately
+     * instead of waiting on the eventual provider webhook.
+     */
+    private threeDsReturnHandler;
+    /** Per-session integrity token to require on outcomes (from mount options). */
+    private messageToken;
+    /** Strict origin to require on outcomes, when configured. */
+    private expectedOrigin;
+    /** Latest merchant theme to push into the (cross-origin) widget. */
+    private theme;
+    /** Latest host submit-gate state to push into the widget (block its submit). */
+    private submitGateBlocked;
+    /** Latest card-field order + autofocus directive to push into the widget. */
+    private cardFieldOrder;
+    private cardAutoFocus;
+    /** Monotonic start of the current widget mount-to-ready machine interval. */
+    private mountStartedAt;
+    private vaultReadyReported;
+    private submissionStarted;
+    private submissionStartedAt;
+    private readonly listeners;
+    constructor(config?: PciVaultCardCaptureConfig);
+    mount(container: HTMLElement, options: CardCaptureMountOptions): Promise<void>;
+    private reportVaultLoadFailure;
+    on(event: CardCaptureEventType, handler: (event: CardCaptureOutcomeEvent) => void): () => void;
+    unmount(): void;
+    /**
+     * Inject the server-rendered widget HTML. `innerHTML` does not execute
+     * embedded `<script>` tags, so each script node is replaced with a freshly
+     * created element that the browser will load and run (this is what boots the
+     * PCIVault form bundle against the `data-flopay-config` container).
+     */
+    private injectWidget;
+    private attachMessageListener;
+    private reportOutcome;
+    /**
+     * Push merchant theme colors into the hosted widget (live). The host calls
+     * this on a runtime theme switch; the widget applies them to its CSS variables
+     * without a remount. Stores the latest theme so `ready` can re-push it.
+     */
+    applyTheme(theme: VaultCardThemeColors): void;
+    /** postMessage the current theme to the widget's (cross-origin) document. */
+    private postTheme;
+    /**
+     * Gate the widget's submit from the host. When `blocked`, the widget cancels
+     * its next submit and emits `'blocked'` instead of `'submitting'` so the host
+     * can validate merchant-DOM fields (AVS) first. Stored so `ready` re-pushes it.
+     */
+    setSubmitGate(blocked: boolean): void;
+    /** postMessage the current submit-gate state to the widget's document. */
+    private postSubmitGate;
+    /**
+     * Push the card-field order + autofocus directive into the widget (live). The
+     * widget re-sequences its rows (DOM order, so tab order follows) and focuses
+     * its first field unless `autoFocus` is false. Stored so `ready` re-pushes it.
+     */
+    setCardFieldOrder(order: VaultCardFieldKey[] | null, autoFocus: boolean): void;
+    /** postMessage the current field order + autofocus to the widget's document. */
+    private postCardFieldOrder;
+    private emit;
+    /**
+     * Render the provider-hosted verification challenge (e.g. Stripe 3DS-2) in a
+     * full-page overlay at the PARENT page level. The widget's inline-iframe
+     * approach is unusable because the SDK's processing backdrop sits above the
+     * vault iframe, hiding any challenge mounted inside it — by lifting the
+     * iframe to the host page the adapter can give it a z-index that wins.
+     *
+     * The overlay tears down on the next terminal outcome
+     * (`complete`/`decline`/`error`) or when the buyer closes it via the backdrop
+     * close button. Closing manually is a soft abandon — the next `/status` poll
+     * either reveals a real outcome (the challenge completed via the issuer's
+     * own redirect to `/vault/3ds/return`, which posts back into the widget) or
+     * surfaces `requires_action` again so the host can decide what to do.
+     */
+    private showActionRequiredOverlay;
+    /**
+     * Tell the vault widget that the buyer has completed (or abandoned) the
+     * challenge. The widget responds by POSTing `/3ds/complete` — its
+     * sub-300ms sync resolver writes the follow-up attempt row immediately,
+     * so the next `/status` poll resolves to a terminal outcome instead of
+     * waiting for the eventual provider webhook.
+     */
+    private postActionCompleted;
+    private abandonActionRequiredOverlay;
+    private hideActionRequiredOverlay;
+    /**
+     * Size the hosted-widget iframe to the height reported by the form inside it.
+     * Cross-origin iframes don't auto-size to their content, so the widget posts
+     * its measured height and we apply it here (clamped to a sane range). This is
+     * what lets the card form shrink/grow to fit instead of sitting at a fixed
+     * height.
+     */
+    private applyHeight;
+}
+
+export { type CardCaptureOperation as C, PaymentAPI as P, SESSION_CREATE_TELEMETRY as S, PciVaultCardCapture as a, type PciVaultCardCaptureConfig as b, type SessionDisplayCacheData as c, type SessionDisplayProduct as d, cacheSessionDisplayData as e, clearSessionDisplayData as f, getSessionDisplayData as g };