@flopay/js 1.4.22 → 1.4.24

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 import * as _flopay_shared from '@flopay/shared';
-import { PaymentProviderAdapter, ElementOptions, ElementType, MountedElement, FloPayError, FloPayConfig, CaptureMethod, CardCaptureAdapter, PayPalPaymentResult, ConfirmPaymentParams, PaymentResult, CheckoutSession, NormalizedCheckoutSession, FloPayThemeVariables, FloPayAppearance, CheckoutSessionMode, CheckoutGateways, VaultCaptureBlock, ProcessPaymentParams, CreateSessionIntentRequest, SessionIntent, SessionIntentDeclineRequest, InlineSessionDraft, DetachedCheckoutSession, CardCaptureProviderId, CardCaptureMountOptions, CardCaptureEventType, CardCaptureOutcomeEvent, VaultCardThemeColors, VaultCardFieldKey, CreateSessionParams, CheckoutSessionResult } from '@flopay/shared';
+import { PaymentProviderAdapter, ElementOptions, ElementType, MountedElement, FloPayError, FloPayConfig, CaptureMethod, CardCaptureAdapter, PayPalPaymentResult, ConfirmPaymentParams, PaymentResult, CheckoutSession, NormalizedCheckoutSession, FloPayThemeVariables, FloPayAppearance, CreateSessionParams, CheckoutSessionResult } from '@flopay/shared';
 export { SentryEventLike, SentryStackFrameLike, dropThirdPartyOnlyError } from '@flopay/shared';
+export { C as CardCaptureOperation, P as PaymentAPI, a as PciVaultCardCapture, b as PciVaultCardCaptureConfig, S as SESSION_CREATE_TELEMETRY, c as SessionDisplayCacheData, d as SessionDisplayProduct, e as cacheSessionDisplayData, f as clearSessionDisplayData, g as getSessionDisplayData } from './card-setup-B8II-Etg.cjs';
 
 /**
  * Manages the creation and lifecycle of payment elements.
@@ -211,592 +212,6 @@ declare class StripeAdapter implements PaymentProviderAdapter {
     destroy(): void;
 }
 
-/**
- * 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;
-}
-
 declare function createCheckoutSession(options: CreateSessionParams): Promise<CheckoutSessionResult>;
 /**
  * Creates a checkout session with automatic retry on transient transport,
@@ -816,4 +231,4 @@ declare function createCheckoutSessionWithRetries(options: CreateSessionParams &
     maxRetries?: number;
 }): Promise<CheckoutSessionResult>;
 
-export { type CardCaptureOperation, FloPay, FloPayElements, PaymentAPI, PciVaultCardCapture, type PciVaultCardCaptureConfig, SESSION_CREATE_TELEMETRY, type SessionDisplayCacheData, type SessionDisplayProduct, StripeAdapter, type StripeSafeAppearance, cacheSessionDisplayData, clearSessionDisplayData, createCheckoutSession, createCheckoutSessionWithRetries, getSessionDisplayData, loadFloPay, toStripeAppearance, toStripeAppearanceTheme };
+export { FloPay, FloPayElements, StripeAdapter, type StripeSafeAppearance, createCheckoutSession, createCheckoutSessionWithRetries, loadFloPay, toStripeAppearance, toStripeAppearanceTheme };