@flopay/vue 0.0.0-stage → 1.13.2

package/dist/index.d.cts

@@ -0,0 +1,1940 @@
+import * as _flopay_shared from '@flopay/shared';
+import { InlineSessionDraft, CheckoutButtonMethod, CheckoutProduct, CheckoutItem, CheckoutSubscription, ThemeId, FloPayAppearance, ButtonsLayoutTheme, ButtonsLayoutStyles, PaymentResult, CheckoutSession, FloPayError, DeclineEvent, PayPalBuyerIdentity, GatewayEnvironment, PayPalProviderObjectType, PayPalApprovalPresentation, InlineSessionPatch, TokenizedBody, TelemetryTerminalReason, BeforeButtonClickEvent, WalletPresentation, AVSFieldConfig, VaultCardFieldKey, CheckoutMode, FloInstrumentEvent, CardCaptureAdapter, VaultCardThemeColors } from '@flopay/shared';
+export { BeforeButtonClickEvent, CheckoutButtonMethod, DeclineEvent, FloInstrumentEvent, InlineSessionDraft, InlineSessionPatch, SentryEventLike, SentryStackFrameLike, WalletPresentation, dropThirdPartyOnlyError } from '@flopay/shared';
+import * as vue from 'vue';
+import { PropType, VNode, ShallowRef, CSSProperties } from 'vue';
+export { FloPayCardSetup, FloPayCardSetupProps } from './card-setup-entry.cjs';
+export { FloPayPaymentMethodSetup, FloPayPaymentMethodSetupCancelEvent, FloPayPaymentMethodSetupCompleteEvent, FloPayPaymentMethodSetupDeclineEvent, FloPayPaymentMethodSetupProps } from './payment-method-setup-entry.cjs';
+import { FloPay } from '@flopay/js';
+export { F as FloPayCardSetupCancelEvent, a as FloPayCardSetupCompleteEvent, b as FloPayCardSetupDeclineEvent, c as FloPayCardSetupError } from './hosted-setup-jpaaXDFA.cjs';
+
+/** Payload of the `success` event — identical to React's `onSuccess` argument. */
+interface FloPayAutomaticPaymentSuccessEvent {
+    result: PaymentResult;
+    session: CheckoutSession | null;
+    sessionId: string | null;
+    autoCompleted: boolean;
+}
+/**
+ * Props for {@link FloPayAutomaticPaymentButton} (React's props; callbacks are
+ * emits). React's props also extend the native `<button>` attributes (minus
+ * `children` and `onError`) and spread them onto the button; in Vue those
+ * arrive as fallthrough attributes (`id`, `class`, `style`, `aria-*`,
+ * `data-*`, `type`, `@click`, …) and land on the same `<button>`.
+ */
+interface FloPayAutomaticPaymentButtonProps {
+    sessionId?: string;
+    /** Session-bound checkout token for a supplied {@link sessionId}. */
+    nonce?: string;
+    createSession?: InlineSessionDraft;
+    /**
+     * @deprecated Ignored, as in React: the backend picks the customer's most
+     * recent vaulted method. Accepted only so existing integrations keep working.
+     */
+    paymentMethodId?: string;
+    /**
+     * @deprecated Ignored, as in React: the backend orchestrates gateway
+     * routing. Accepted only so existing integrations keep working.
+     */
+    checkoutMethod?: CheckoutButtonMethod;
+    clientId?: string;
+    products?: CheckoutProduct[];
+    items?: CheckoutItem[];
+    subscriptions?: CheckoutSubscription[];
+    account?: InlineSessionDraft['account'];
+    successUrl?: string;
+    cancelUrl?: string;
+    couponCodes?: string[];
+    tagsData?: InlineSessionDraft['tagsData'];
+    utmMetadata?: InlineSessionDraft['utmMetadata'];
+    billingApiUrl?: string;
+    locale?: string;
+    disabled?: boolean;
+    /** Theme bundle that styles the button and the fallback checkout. */
+    theme?: ThemeId;
+    /**
+     * Appearance overrides layered on top of the chosen `theme` (variables merge
+     * per key). Its `colorPrimary` / `colorPrimaryHover` re-skin the button.
+     */
+    appearance?: FloPayAppearance;
+    /** @deprecated Use `theme`. Legacy buttons-layout preset, used only without `theme`. */
+    buttonsTheme?: ButtonsLayoutTheme;
+    /** Style overrides merged on top of the resolved theme bundle / `buttonsTheme` preset. */
+    buttonsStyles?: ButtonsLayoutStyles;
+}
+/**
+ * The one-click button: charges the buyer's saved payment method through the
+ * session-scoped `/process` with no client-built `tokenizedData`. The backend
+ * picks the vaulted method and its gateway. A session the backend already
+ * auto-completed emits `success` with `autoCompleted: true`.
+ */
+declare const FloPayAutomaticPaymentButton: vue.DefineComponent<vue.ExtractPropTypes<{
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    createSession: {
+        type: PropType<InlineSessionDraft>;
+        default: undefined;
+    };
+    paymentMethodId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    checkoutMethod: {
+        type: PropType<CheckoutButtonMethod>;
+        default: undefined;
+    };
+    clientId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    products: {
+        type: PropType<CheckoutProduct[]>;
+        default: undefined;
+    };
+    items: {
+        type: PropType<CheckoutItem[]>;
+        default: undefined;
+    };
+    subscriptions: {
+        type: PropType<CheckoutSubscription[]>;
+        default: undefined;
+    };
+    account: {
+        type: PropType<InlineSessionDraft["account"]>;
+        default: undefined;
+    };
+    successUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    cancelUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    couponCodes: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    tagsData: {
+        type: PropType<InlineSessionDraft["tagsData"]>;
+        default: undefined;
+    };
+    utmMetadata: {
+        type: PropType<InlineSessionDraft["utmMetadata"]>;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    theme: {
+        type: PropType<ThemeId>;
+        default: undefined;
+    };
+    appearance: {
+        type: PropType<FloPayAppearance>;
+        default: undefined;
+    };
+    buttonsTheme: {
+        type: PropType<ButtonsLayoutTheme>;
+        default: undefined;
+    };
+    buttonsStyles: {
+        type: PropType<ButtonsLayoutStyles>;
+        default: undefined;
+    };
+}>, () => (vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null)[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    success: (_event: FloPayAutomaticPaymentSuccessEvent) => true;
+    error: (_error: FloPayError) => true;
+    decline: (_decline: DeclineEvent) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    createSession: {
+        type: PropType<InlineSessionDraft>;
+        default: undefined;
+    };
+    paymentMethodId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    checkoutMethod: {
+        type: PropType<CheckoutButtonMethod>;
+        default: undefined;
+    };
+    clientId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    products: {
+        type: PropType<CheckoutProduct[]>;
+        default: undefined;
+    };
+    items: {
+        type: PropType<CheckoutItem[]>;
+        default: undefined;
+    };
+    subscriptions: {
+        type: PropType<CheckoutSubscription[]>;
+        default: undefined;
+    };
+    account: {
+        type: PropType<InlineSessionDraft["account"]>;
+        default: undefined;
+    };
+    successUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    cancelUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    couponCodes: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    tagsData: {
+        type: PropType<InlineSessionDraft["tagsData"]>;
+        default: undefined;
+    };
+    utmMetadata: {
+        type: PropType<InlineSessionDraft["utmMetadata"]>;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    theme: {
+        type: PropType<ThemeId>;
+        default: undefined;
+    };
+    appearance: {
+        type: PropType<FloPayAppearance>;
+        default: undefined;
+    };
+    buttonsTheme: {
+        type: PropType<ButtonsLayoutTheme>;
+        default: undefined;
+    };
+    buttonsStyles: {
+        type: PropType<ButtonsLayoutStyles>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onError?: ((_error: FloPayError) => any) | undefined;
+    onDecline?: ((_decline: DeclineEvent) => any) | undefined;
+    onSuccess?: ((_event: FloPayAutomaticPaymentSuccessEvent) => any) | undefined;
+}>, {
+    nonce: string;
+    account: Omit<_flopay_shared.CheckoutAccount, "email"> & {
+        email?: string;
+    };
+    disabled: boolean;
+    sessionId: string;
+    billingApiUrl: string;
+    clientId: string;
+    appearance: FloPayAppearance;
+    theme: ThemeId;
+    buttonsTheme: ButtonsLayoutTheme;
+    buttonsStyles: ButtonsLayoutStyles;
+    products: CheckoutProduct[];
+    successUrl: string;
+    cancelUrl: string;
+    tagsData: _flopay_shared.TagsData | undefined;
+    items: CheckoutItem[];
+    subscriptions: CheckoutSubscription[];
+    couponCodes: string[];
+    utmMetadata: Record<string, string | null | undefined>[] | undefined;
+    createSession: InlineSessionDraft;
+    locale: string;
+    paymentMethodId: string;
+    checkoutMethod: CheckoutButtonMethod;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Lifecycle of the PayPal JS SDK button, reported through `@initialization-state-change`. */
+type DirectPayPalInitializationState = 'loading' | 'retrying' | 'ready' | 'exhausted';
+/** React's click-time `runBeforeButtonClick` result. */
+interface DirectPayPalBeforeButtonClickResult {
+    proceed: boolean;
+    accountPatch?: InlineSessionPatch['account'];
+    sessionId?: string;
+    nonce?: string;
+}
+/**
+ * React's click-time gate: runs before PayPal creates the order, can patch the
+ * session, nonce and account for this attempt, or stop it with `proceed: false`.
+ */
+type DirectPayPalRunBeforeButtonClick = (method: CheckoutButtonMethod) => Promise<DirectPayPalBeforeButtonClickResult>;
+/** The click-time patch React passes with the tokenized body. */
+interface DirectPayPalTokenizedOverrides {
+    accountPatch?: InlineSessionPatch['account'];
+    sessionId?: string;
+    nonce?: string;
+}
+/** React's `onTokenizedBody`: when set, the host continues the payment from PayPal's approval. */
+type DirectPayPalTokenizedHandler = (body: TokenizedBody, overrides?: DirectPayPalTokenizedOverrides) => void | Promise<void>;
+interface DirectPayPalTechnicalFailureOptions {
+    code?: string;
+    popupBlocked?: boolean;
+    provider?: 'paypal';
+    paymentMethodCategory?: 'paypal';
+    terminalReason?: TelemetryTerminalReason;
+}
+/**
+ * React's `onBuyerIdentityReady`: attaches the buyer identity collected on
+ * approval before the payment continues. React awaits it and its presence
+ * turns on the email fallback, so it stays a function prop (CTO decision 2).
+ */
+type DirectPayPalBuyerIdentityReadyHandler = (identity: PayPalBuyerIdentity) => void | Promise<void>;
+/** React's `onTechnicalFailure`: when set, it receives post-click failures instead of `errorChange`. */
+type DirectPayPalTechnicalFailureHandler = (method: 'paypal', err: unknown, options?: DirectPayPalTechnicalFailureOptions) => void;
+/** Props for {@link DirectPayPalButton} (React's `DirectPayPalButtonProps`; notifying callbacks are emits). */
+interface DirectPayPalButtonProps {
+    sessionId: string;
+    /** Session-bound checkout token, sent as `x-checkout-session-token`. */
+    nonce?: string;
+    billingApiUrl?: string;
+    email?: string;
+    /** Buyer name already attached to the checkout, when available. */
+    billingName?: string;
+    /** Attaches the buyer identity collected on PayPal approval before checkout continues. */
+    onBuyerIdentityReady?: DirectPayPalBuyerIdentityReadyHandler;
+    /** PayPal client id the session advertises in `gateways.paypal`. */
+    clientId: string;
+    /**
+     * React's `GatewayEnvironment`. FloPay's `stage` / `production` aliases are
+     * collapsed to PayPal's `sandbox` / `production` before the SDK loads.
+     */
+    environment?: GatewayEnvironment;
+    currency?: string;
+    isSubscription?: boolean;
+    /**
+     * @deprecated The session's `gateways.paypal.providerObjectType` is
+     * authoritative; this is the fallback when the session advertises none.
+     */
+    providerObjectType?: PayPalProviderObjectType;
+    /**
+     * Backend-advertised approval presentation. The session's
+     * `gateways.paypal.approvalPresentation` wins when both are supplied.
+     */
+    approvalPresentation?: PayPalApprovalPresentation;
+    /** The session, whose `gateways.paypal.providerObjectType` selects the channel. */
+    session?: CheckoutSession | null;
+    /** A PayPal order (or subscription) id to bind the button to; changing it remounts PayPal. */
+    existingOrderId?: string;
+    /** External processing state: marks the PayPal container busy. */
+    isProcessing?: boolean;
+    /** `false` turns off the one automatic startup retry. Defaults to `true`. */
+    allowAutomaticRetry?: boolean;
+    /** Click-time gate that runs before PayPal creates the order. */
+    runBeforeButtonClick?: DirectPayPalRunBeforeButtonClick;
+    /** When set, PayPal's approval is handed to the host instead of completing here. */
+    onTokenizedBody?: DirectPayPalTokenizedHandler;
+    /** When set, post-click technical failures go here instead of `errorChange`. */
+    onTechnicalFailure?: DirectPayPalTechnicalFailureHandler;
+    telemetry?: boolean;
+    /** Renders React's on-screen lifecycle tracer above the button. Off by default. */
+    debug?: boolean;
+}
+/**
+ * Renders PayPal's own JS SDK button for a session that advertises
+ * `gateways.paypal` — the path that works inside in-app browsers. The PayPal
+ * object (order or subscription) is created by the billing API's
+ * session-scoped `/intents` endpoint, unless `existingOrderId` binds the
+ * button to one the backend already created; the SDK only relays the buyer's
+ * approval.
+ *
+ * Like React's button, a load or render failure is retried once automatically
+ * (`retrying`, unless `allowAutomaticRetry` is false) before the button reports
+ * `exhausted`, and every PayPal error is classified with the shared
+ * external-method classifier: only a provider decline is reported to
+ * `/intents/decline` and emitted as `decline`. A blocked pop-up or PayPal's
+ * dead window in an in-app browser is emitted as `error` carrying the shared
+ * recovery copy, and that copy also goes to `errorChange` (or to
+ * `onTechnicalFailure` when the host passes one).
+ *
+ * Each click starts an attempt with a fresh `/intents` idempotency key. The
+ * buyer's approval goes to the host's `onTokenizedBody` when it passes one;
+ * otherwise the button posts it to `/process` itself, as React does. A failed
+ * approval is forwarded as a message only, never reported as a decline.
+ */
+declare const DirectPayPalButton: vue.DefineComponent<vue.ExtractPropTypes<{
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    email: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    billingName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    onBuyerIdentityReady: {
+        type: PropType<DirectPayPalBuyerIdentityReadyHandler>;
+        default: undefined;
+    };
+    clientId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    environment: {
+        type: PropType<GatewayEnvironment>;
+        default: undefined;
+    };
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isSubscription: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    providerObjectType: {
+        type: PropType<PayPalProviderObjectType>;
+        default: undefined;
+    };
+    approvalPresentation: {
+        type: PropType<PayPalApprovalPresentation>;
+        default: undefined;
+    };
+    session: {
+        type: PropType<CheckoutSession | null>;
+        default: null;
+    };
+    existingOrderId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isProcessing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowAutomaticRetry: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    runBeforeButtonClick: {
+        type: PropType<DirectPayPalRunBeforeButtonClick>;
+        default: undefined;
+    };
+    onTokenizedBody: {
+        type: PropType<DirectPayPalTokenizedHandler>;
+        default: undefined;
+    };
+    onTechnicalFailure: {
+        type: PropType<DirectPayPalTechnicalFailureHandler>;
+        default: undefined;
+    };
+    telemetry: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    complete: (_result: PaymentResult) => true;
+    decline: (_decline: DeclineEvent) => true;
+    error: (_error: FloPayError) => true;
+    errorChange: (_message: string | null) => true;
+    buttonClick: (_method: CheckoutButtonMethod) => true;
+    loadStateChange: (_ready: boolean) => true;
+    initializationStateChange: (_state: DirectPayPalInitializationState) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    email: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    billingName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    onBuyerIdentityReady: {
+        type: PropType<DirectPayPalBuyerIdentityReadyHandler>;
+        default: undefined;
+    };
+    clientId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    environment: {
+        type: PropType<GatewayEnvironment>;
+        default: undefined;
+    };
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isSubscription: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    providerObjectType: {
+        type: PropType<PayPalProviderObjectType>;
+        default: undefined;
+    };
+    approvalPresentation: {
+        type: PropType<PayPalApprovalPresentation>;
+        default: undefined;
+    };
+    session: {
+        type: PropType<CheckoutSession | null>;
+        default: null;
+    };
+    existingOrderId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isProcessing: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowAutomaticRetry: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    runBeforeButtonClick: {
+        type: PropType<DirectPayPalRunBeforeButtonClick>;
+        default: undefined;
+    };
+    onTokenizedBody: {
+        type: PropType<DirectPayPalTokenizedHandler>;
+        default: undefined;
+    };
+    onTechnicalFailure: {
+        type: PropType<DirectPayPalTechnicalFailureHandler>;
+        default: undefined;
+    };
+    telemetry: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onComplete?: ((_result: PaymentResult) => any) | undefined;
+    onError?: ((_error: FloPayError) => any) | undefined;
+    onDecline?: ((_decline: DeclineEvent) => any) | undefined;
+    onErrorChange?: ((_message: string | null) => any) | undefined;
+    onButtonClick?: ((_method: CheckoutButtonMethod) => any) | undefined;
+    onLoadStateChange?: ((_ready: boolean) => any) | undefined;
+    onInitializationStateChange?: ((_state: DirectPayPalInitializationState) => any) | undefined;
+}>, {
+    session: CheckoutSession | null;
+    nonce: string;
+    email: string;
+    sessionId: string;
+    billingApiUrl: string;
+    billingName: string;
+    onBuyerIdentityReady: DirectPayPalBuyerIdentityReadyHandler;
+    clientId: string;
+    environment: GatewayEnvironment;
+    currency: string;
+    isSubscription: boolean;
+    providerObjectType: PayPalProviderObjectType;
+    approvalPresentation: PayPalApprovalPresentation;
+    existingOrderId: string;
+    isProcessing: boolean;
+    allowAutomaticRetry: boolean;
+    runBeforeButtonClick: DirectPayPalRunBeforeButtonClick;
+    onTokenizedBody: DirectPayPalTokenizedHandler;
+    onTechnicalFailure: DirectPayPalTechnicalFailureHandler;
+    telemetry: boolean;
+    debug: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * React's `onBeforeButtonClick`: runs before a payment button continues.
+ * `false` stops the click; a patch's `account` goes with this attempt.
+ */
+type SplitCardFormBeforeButtonClick = (event: BeforeButtonClickEvent) => undefined | false | InlineSessionPatch | Promise<undefined | false | InlineSessionPatch>;
+/** React's `onBuyerIdentityReady`: awaited after PayPal's approval collects a missing identity. */
+type SplitCardFormBuyerIdentityReady = (identity: NonNullable<InlineSessionPatch['account']>) => void | Promise<void>;
+/**
+ * React's `directPaypal`: the direct PayPal gateway. When set it wins over the
+ * session's `gateways.paypal`, and PayPal renders through the PayPal JS SDK.
+ */
+interface SplitCardFormDirectPayPal {
+    clientId: string;
+    /** React's `GatewayEnvironment`: `stage` and `production` are FloPay's aliases. */
+    environment?: _flopay_shared.GatewayEnvironment;
+    /**
+     * @deprecated The session's `gateways.paypal.providerObjectType` wins.
+     * Kept as a fallback for integrations that pass no session.
+     */
+    providerObjectType?: _flopay_shared.PayPalProviderObjectType;
+    /** Backend-advertised non-popup presentation for a one-time PayPal order. */
+    approvalPresentation?: _flopay_shared.PayPalApprovalPresentation;
+    /** Backend-created PayPal order to resume instead of creating a new one. */
+    existingOrderId?: string;
+}
+/** React's `onTokenizedBody` on the form: the host continues the payment from the body. */
+type SplitCardFormTokenizedBodyHandler = (tokenizedBody: TokenizedBody) => void;
+/** Props for {@link SplitCardForm} (React's `SplitCardFormProps`; callbacks are emits). */
+interface SplitCardFormProps {
+    session?: CheckoutSession | null;
+    sessionId?: string;
+    nonce?: string;
+    billingApiUrl?: string;
+    telemetry?: boolean;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    layout?: 'default' | 'buttons';
+    initialCardOpen?: boolean;
+    showPayPal?: boolean;
+    /**
+     * React's `walletPresentation`: the preferred approval presentation for
+     * Stripe-routed PayPal. Defaults to `'auto'` (or the value `FloPayCheckout`
+     * hands a custom-layout form). `prefer_redirect` renders PayPal as a
+     * full-page redirect tile; an in-app browser or a blocked pop-up does the
+     * same whatever the preference, as safety signals stay authoritative.
+     */
+    walletPresentation?: WalletPresentation;
+    showStripe?: boolean;
+    /** @deprecated Session-driven visibility (`enabledPaymentMethods`) decides. */
+    showApplePay?: boolean;
+    /** @deprecated Session-driven visibility (`enabledPaymentMethods`) decides. */
+    showGooglePay?: boolean;
+    /** Explicit Stripe method list; `[]` asks for card only. Defaults to the session's. */
+    enabledPaymentMethods?: string[];
+    /** True while a detached session's catalog is still being attached: payment is gated. */
+    dataAttachmentPending?: boolean;
+    /**
+     * React's `dataAttachmentRequiresIdentity`: the pending claim waits for this
+     * form to collect the buyer's identity. The wallets and APMs then stay
+     * available so they can collect it, and a non-card click does not wait for
+     * the claim first. Card submit stays gated while the claim is pending. A
+     * form inside `FloPayCheckout` also reads the checkout's `claimRequiresIdentity`.
+     */
+    dataAttachmentRequiresIdentity?: boolean;
+    /** Final, localized wording for the hosted card form's submit button. */
+    submitLabel?: string | null;
+    /** Address verification: `true` (country + postcode) or per-field {@link AVSFieldConfig}. */
+    enableAVS?: boolean | AVSFieldConfig;
+    /** Layout for AVS fields: `row` (side by side, default) or `column` (stacked). */
+    avsLayout?: 'row' | 'column';
+    /** Initial AVS country (ISO 3166-1 alpha-2). Defaults to the session customer's. */
+    country?: string;
+    /** Initial AVS postal code. Defaults to the session customer's. */
+    zip?: string;
+    /** Initial AVS street address (line 1), e.g. from a GeoIP or profile lookup. */
+    addressLine1?: string;
+    /** Initial AVS apt / suite / unit (line 2). */
+    addressLine2?: string;
+    /** Initial AVS city. */
+    city?: string;
+    /** Initial AVS state / province. */
+    state?: string;
+    /**
+     * External processing state, as React's `isProcessing`: while `true` the
+     * AVS fields and the buttons-layout card tile are disabled.
+     */
+    isProcessing?: boolean;
+    /** External error message. It is shown in place of the form's own (React's `error`). */
+    error?: string | null;
+    /**
+     * Theme bundle for the card tile, the card container, the hosted vault
+     * widget and the Stripe methods. `'classic'` (or none) applies no bundle.
+     */
+    theme?: ThemeId;
+    /** @deprecated Use `theme`. Legacy buttons-layout preset, used only without `theme`. */
+    buttonsTheme?: ButtonsLayoutTheme;
+    /** Style overrides merged on top of the resolved theme bundle / `buttonsTheme` preset. */
+    buttonsStyles?: ButtonsLayoutStyles;
+    /** Appearance override; wins over the theme bundle's appearance. */
+    appearance?: FloPayAppearance;
+    /** Additional CSS class for the form wrapper. */
+    className?: string;
+    /**
+     * Order of the hosted vault card rows, a permutation of
+     * `['name', 'number', 'expiry']`. It sets both the visual and the tab order.
+     * Omit it for the default order. Vault card path only.
+     */
+    cardFieldOrder?: VaultCardFieldKey[];
+    /**
+     * React's `onBeforeButtonClick` (a function prop: its result is read). It
+     * runs before the buttons-layout card tile opens and before PayPal creates
+     * its order, with `{ method, sessionId, createSession }`. `false` stops the
+     * click, a returned `account` goes with the attempt, and a throw is shown
+     * and emitted as a `validation_error`.
+     */
+    onBeforeButtonClick?: SplitCardFormBeforeButtonClick;
+    /** React's `onBuyerIdentityReady`, passed to the PayPal button (awaited on approval). */
+    onBuyerIdentityReady?: SplitCardFormBuyerIdentityReady;
+    /**
+     * The buyer's user id, sent as `accountData.userId` in the `/account`
+     * snapshot (React's `userId`). A before-click `account.userId` wins over it.
+     * Without either, `''` is sent, as in React. `FloPayCheckout` passes the
+     * session customer's id.
+     */
+    userId?: string;
+    /**
+     * Whether AVS was enabled, sent as `avsCheck` in the `/account` snapshot for
+     * analytics (React's `avsCheck`). Omitted from the snapshot when not set.
+     * `FloPayCheckout` passes `!!enableAVS`.
+     */
+    avsCheck?: boolean;
+    /**
+     * @deprecated No longer rendered, as in React: the default-layout security
+     * footer was removed with the theme bundles. Kept so integrations that pass
+     * it still type-check.
+     */
+    showSecurityFooter?: boolean;
+    /**
+     * React's `directPaypal`. When set it wins over the session's
+     * `gateways.paypal`. A backend-created `existingOrderId` given at mount is
+     * resumed, with React's notice asking the buyer to confirm the payment.
+     */
+    directPaypal?: SplitCardFormDirectPayPal;
+    /**
+     * Currency for PayPal and the Stripe methods (React's `currency`). Default
+     * `'usd'`, as in React: the session's currency is not read here, and
+     * `FloPayCheckout` passes it for its built-in form.
+     */
+    currency?: string;
+    /**
+     * Whether this is a subscription, for direct PayPal (React's
+     * `isSubscription`). Default `false`; `FloPayCheckout` passes the session's mode.
+     */
+    isSubscription?: boolean;
+    /**
+     * React's per-method buyer-country gate
+     * (`gateways.stripe.enabledPaymentMethodCountries`): method → allowed
+     * ISO 3166-1 alpha-2 countries. Methods other than the wallet row are
+     * filtered by the buyer's live country. Without it, the SDK's built-in
+     * country table decides.
+     */
+    enabledPaymentMethodCountries?: Record<string, string[]>;
+    /**
+     * React's `debug`: on-screen panels for the PayPal and Stripe gating
+     * decisions, and the PayPal button's lifecycle tracer. Off by default.
+     */
+    debug?: boolean;
+    /**
+     * React's `onTokenizedBody` (a function prop: it replaces the SDK's own
+     * `/process`). PayPal's approval body goes to the host instead. Without it
+     * the form posts `/process` itself, as React's `dispatchTokenizedBody` does.
+     */
+    onTokenizedBody?: SplitCardFormTokenizedBodyHandler;
+    /** React's `chv`: forwarded as is on the form's own `/process` request. */
+    chv?: string;
+    /**
+     * React's `checkoutType` (`standard_checkout` / `embedded_checkout`), sent
+     * as analytics metadata on the form's own `/process` request.
+     * `FloPayCheckout` passes it for its built-in form.
+     */
+    checkoutType?: string;
+    /**
+     * React's `checkoutLayout` (`default_layout` / `buttons_layout` /
+     * `custom_layout`), sent as analytics metadata on the form's own
+     * `/process` request. `FloPayCheckout` passes it for its built-in form.
+     */
+    checkoutLayout?: string;
+}
+/**
+ * The checkout form: the hosted vault card widget (through the SDK's
+ * `cardCapture` adapter — card data never touches Stripe.js here), plus the
+ * wallets, APMs and PayPal the session advertises. It renders exactly what
+ * the session advertises; with no vault block and nothing else usable it
+ * raises `UnsupportedBackendVaultCapability` rather than falling back.
+ *
+ * Inside a `FloPayCheckout` custom layout it reads the session, nonce and
+ * `submitLabel` from the checkout unless it sets them itself.
+ */
+declare const SplitCardForm: vue.DefineComponent<vue.ExtractPropTypes<{
+    session: {
+        type: PropType<CheckoutSession | null>;
+        default: undefined;
+    };
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    telemetry: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    email: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    firstName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    lastName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    layout: {
+        type: PropType<"default" | "buttons">;
+        default: string;
+    };
+    initialCardOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPayPal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    walletPresentation: {
+        type: PropType<WalletPresentation>;
+        default: undefined;
+    };
+    showStripe: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showApplePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showGooglePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabledPaymentMethods: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    dataAttachmentPending: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    dataAttachmentRequiresIdentity: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    submitLabel: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    enableAVS: {
+        type: PropType<boolean | AVSFieldConfig>;
+        default: undefined;
+    };
+    avsLayout: {
+        type: PropType<"row" | "column">;
+        default: string;
+    };
+    country: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    zip: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    addressLine1: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    addressLine2: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    city: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    state: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isProcessing: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    error: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    theme: {
+        type: PropType<ThemeId>;
+        default: undefined;
+    };
+    buttonsTheme: {
+        type: PropType<ButtonsLayoutTheme>;
+        default: undefined;
+    };
+    buttonsStyles: {
+        type: PropType<ButtonsLayoutStyles>;
+        default: undefined;
+    };
+    appearance: {
+        type: PropType<FloPayAppearance>;
+        default: undefined;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    cardFieldOrder: {
+        type: PropType<VaultCardFieldKey[]>;
+        default: undefined;
+    };
+    onBeforeButtonClick: {
+        type: PropType<SplitCardFormBeforeButtonClick>;
+        default: undefined;
+    };
+    onBuyerIdentityReady: {
+        type: PropType<SplitCardFormBuyerIdentityReady>;
+        default: undefined;
+    };
+    userId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    avsCheck: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** @deprecated Not rendered (React's deprecated `showSecurityFooter`). */
+    showSecurityFooter: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    directPaypal: {
+        type: PropType<SplitCardFormDirectPayPal>;
+        default: undefined;
+    };
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isSubscription: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     * React's `totalAmount`: the cart total due today, in minor units
+     * (`FloPayCheckout` passes it). Payment-mode Stripe Elements use
+     * `totalAmount || 100` (React's `amountInCents` placeholder for a $0 cart),
+     * and the wallet row runs in setup mode for $0. Default `0`, as React's.
+     */
+    totalAmount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onTokenizedBody: {
+        type: PropType<SplitCardFormTokenizedBodyHandler>;
+        default: undefined;
+    };
+    chv: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    checkoutType: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    checkoutLayout: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabledPaymentMethodCountries: {
+        type: PropType<Record<string, string[]>>;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    complete: (_result: PaymentResult) => true;
+    error: (_error: FloPayError) => true;
+    decline: (_decline: DeclineEvent) => true;
+    buttonClick: (_method: CheckoutButtonMethod) => true;
+    countryChange: (_country: string) => true;
+    zipChange: (_zip: string) => true;
+    errorChange: (_error: string | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    session: {
+        type: PropType<CheckoutSession | null>;
+        default: undefined;
+    };
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    telemetry: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    email: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    firstName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    lastName: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    layout: {
+        type: PropType<"default" | "buttons">;
+        default: string;
+    };
+    initialCardOpen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPayPal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    walletPresentation: {
+        type: PropType<WalletPresentation>;
+        default: undefined;
+    };
+    showStripe: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showApplePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showGooglePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabledPaymentMethods: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    dataAttachmentPending: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    dataAttachmentRequiresIdentity: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    submitLabel: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    enableAVS: {
+        type: PropType<boolean | AVSFieldConfig>;
+        default: undefined;
+    };
+    avsLayout: {
+        type: PropType<"row" | "column">;
+        default: string;
+    };
+    country: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    zip: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    addressLine1: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    addressLine2: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    city: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    state: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isProcessing: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    error: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    theme: {
+        type: PropType<ThemeId>;
+        default: undefined;
+    };
+    buttonsTheme: {
+        type: PropType<ButtonsLayoutTheme>;
+        default: undefined;
+    };
+    buttonsStyles: {
+        type: PropType<ButtonsLayoutStyles>;
+        default: undefined;
+    };
+    appearance: {
+        type: PropType<FloPayAppearance>;
+        default: undefined;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    cardFieldOrder: {
+        type: PropType<VaultCardFieldKey[]>;
+        default: undefined;
+    };
+    onBeforeButtonClick: {
+        type: PropType<SplitCardFormBeforeButtonClick>;
+        default: undefined;
+    };
+    onBuyerIdentityReady: {
+        type: PropType<SplitCardFormBuyerIdentityReady>;
+        default: undefined;
+    };
+    userId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    avsCheck: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** @deprecated Not rendered (React's deprecated `showSecurityFooter`). */
+    showSecurityFooter: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    directPaypal: {
+        type: PropType<SplitCardFormDirectPayPal>;
+        default: undefined;
+    };
+    currency: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isSubscription: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     * React's `totalAmount`: the cart total due today, in minor units
+     * (`FloPayCheckout` passes it). Payment-mode Stripe Elements use
+     * `totalAmount || 100` (React's `amountInCents` placeholder for a $0 cart),
+     * and the wallet row runs in setup mode for $0. Default `0`, as React's.
+     */
+    totalAmount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onTokenizedBody: {
+        type: PropType<SplitCardFormTokenizedBodyHandler>;
+        default: undefined;
+    };
+    chv: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    checkoutType: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    checkoutLayout: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enabledPaymentMethodCountries: {
+        type: PropType<Record<string, string[]>>;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onComplete?: ((_result: PaymentResult) => any) | undefined;
+    onError?: ((_error: FloPayError) => any) | undefined;
+    onDecline?: ((_decline: DeclineEvent) => any) | undefined;
+    onErrorChange?: ((_error: string | null) => any) | undefined;
+    onButtonClick?: ((_method: CheckoutButtonMethod) => any) | undefined;
+    onCountryChange?: ((_country: string) => any) | undefined;
+    onZipChange?: ((_zip: string) => any) | undefined;
+}>, {
+    layout: "default" | "buttons";
+    session: CheckoutSession | null;
+    nonce: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    city: string;
+    state: string;
+    country: string;
+    zip: string;
+    userId: string;
+    addressLine1: string;
+    addressLine2: string;
+    error: string | null;
+    sessionId: string;
+    billingApiUrl: string;
+    onBuyerIdentityReady: SplitCardFormBuyerIdentityReady;
+    currency: string;
+    isSubscription: boolean;
+    isProcessing: boolean;
+    onTokenizedBody: SplitCardFormTokenizedBodyHandler;
+    telemetry: boolean;
+    debug: boolean;
+    totalAmount: number;
+    appearance: FloPayAppearance;
+    theme: ThemeId;
+    submitLabel: string | null;
+    initialCardOpen: boolean;
+    showPayPal: boolean;
+    walletPresentation: WalletPresentation;
+    showStripe: boolean;
+    showApplePay: boolean;
+    showGooglePay: boolean;
+    enabledPaymentMethods: string[];
+    dataAttachmentPending: boolean;
+    dataAttachmentRequiresIdentity: boolean;
+    enableAVS: boolean | AVSFieldConfig;
+    avsLayout: "column" | "row";
+    buttonsTheme: ButtonsLayoutTheme;
+    buttonsStyles: ButtonsLayoutStyles;
+    className: string;
+    cardFieldOrder: VaultCardFieldKey[];
+    onBeforeButtonClick: SplitCardFormBeforeButtonClick;
+    avsCheck: boolean;
+    showSecurityFooter: boolean;
+    directPaypal: SplitCardFormDirectPayPal;
+    chv: string;
+    checkoutType: string;
+    checkoutLayout: string;
+    enabledPaymentMethodCountries: Record<string, string[]>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Props for {@link FloPayCheckout} (React's `FloPayCheckoutProps`; callbacks are emits). */
+interface FloPayCheckoutProps {
+    /** An existing checkout session id (with its `nonce`). */
+    sessionId?: string;
+    /** Session-bound checkout token returned with {@link FloPayCheckoutProps.sessionId}. */
+    nonce?: string;
+    /** Inline session draft: the checkout creates the session itself. */
+    createSession?: InlineSessionDraft;
+    billingApiUrl?: string;
+    telemetry?: boolean;
+    locale?: string;
+    layout?: 'default' | 'buttons';
+    showPayPal?: boolean;
+    showStripe?: boolean;
+    /** Explicit Stripe method list (`[]` = card only); defaults to the session's. */
+    enabledPaymentMethods?: string[];
+    /** @deprecated Session-driven visibility (`enabledPaymentMethods`) decides. */
+    showApplePay?: boolean;
+    /** @deprecated Session-driven visibility (`enabledPaymentMethods`) decides. */
+    showGooglePay?: boolean;
+    /**
+     * Theme bundle (`'classic'`, `'modern-light'`, `'modern-dark'`, `'bold-light'`,
+     * `'bold-dark'`, `'glass-light'`, `'glass-dark'`) for the card form, the
+     * hosted vault widget and the Stripe methods. Explicit `appearance` /
+     * `buttonsStyles` still override their halves.
+     */
+    theme?: ThemeId;
+    /** Visual appearance for the payment elements; wins over the theme bundle's. */
+    appearance?: FloPayAppearance;
+    /** @deprecated Use `theme`. Legacy buttons-layout preset, used only without `theme`. */
+    buttonsTheme?: ButtonsLayoutTheme;
+    /** Style overrides merged on top of the resolved theme bundle / `buttonsTheme` preset. */
+    buttonsStyles?: ButtonsLayoutStyles;
+    /** Additional CSS class for the form wrapper. */
+    className?: string;
+    /** Final, localized wording for the hosted card form's submit button. */
+    submitLabel?: string | null;
+    /** Address verification: `true` (country + postcode) or per-field {@link AVSFieldConfig}. */
+    enableAVS?: boolean | AVSFieldConfig;
+    /** Layout for AVS fields: `row` (side by side, default) or `column` (stacked). */
+    avsLayout?: 'row' | 'column';
+    /**
+     * Order of the hosted vault card rows, a permutation of
+     * `['name', 'number', 'expiry']` (visual and tab order). Vault card path only.
+     */
+    cardFieldOrder?: VaultCardFieldKey[];
+    /**
+     * @deprecated Not rendered, as in React: the default-layout security footer
+     * was removed. Accepted so integrations ported from React keep compiling.
+     */
+    showSecurityFooter?: boolean;
+    /**
+     * @deprecated Ignored, as in React: the Stripe publishable key comes only
+     * from the session's `gateways.stripe.publishableKey`.
+     */
+    fallbackPublishableKey?: string;
+    /**
+     * Override the session's `checkoutMode`: `'full'` shows the payment form
+     * (default), `'confirm'` a confirm button that charges the saved payment
+     * method, `'auto'` charges it on mount and falls back to `'full'` on failure.
+     */
+    checkoutMode?: CheckoutMode;
+    /**
+     * Label for the saved-payment confirm button in `confirm` mode. Default:
+     * `'Confirm Purchase'`. The hosted card button uses `submitLabel` instead.
+     * React's `renderConfirmButton` is the `renderConfirmButton` slot, which
+     * receives `{ onConfirm, isProcessing }`.
+     */
+    confirmLabel?: string;
+    /**
+     * Seed a checkout error message: shown above the confirm button or the
+     * payment form until the buyer's next attempt.
+     */
+    initialErrorMessage?: string | null;
+    /**
+     * React's `initialPayPalOrderId`: a backend-created PayPal order to resume
+     * instead of creating a new one. It goes to the built-in form's
+     * `directPaypal.existingOrderId`.
+     */
+    initialPayPalOrderId?: string;
+    /** React's `debug`: the built-in form's gating panels and PayPal tracer. Off by default. */
+    debug?: boolean;
+}
+/**
+ * The all-in-one checkout. Given `createSession`, an inline full-mode session
+ * is created detached (`deferDataAttachment: true`): the hosted card form
+ * mounts from the shell while the catalog is attached by a background claim,
+ * and payment is gated only until that claim settles. `deferDataAttachment:
+ * false` keeps the one-shot create. It renders exactly the methods the
+ * session advertises and sends no gateway hint or provider selection.
+ *
+ * Slots: `default` renders inside the checkout context (alongside the form);
+ * `layout` replaces the built-in `SplitCardForm` with a custom layout, whose
+ * `SplitCardForm` receives the session, nonce and `submitLabel` unless it
+ * sets them itself. `cardButtonContent`, `cardBackButtonContent`,
+ * `cardTitleContent` and `cardPreFormSlot` (React's content props) pass to
+ * the built-in `SplitCardForm`. `renderConfirmButton` (React's render prop)
+ * replaces the `confirm`-mode button and receives `{ onConfirm, isProcessing }`.
+ *
+ * Modes (React's): `full` renders the payment form; `confirm` renders a
+ * confirm button that charges the buyer's saved payment method; `auto`
+ * charges it on mount. A failed saved payment shows its error and falls back
+ * to `full`. A session that is already paid emits `sessionCompleted` with its
+ * success URL (an authorized one also `complete`) and renders no form.
+ */
+declare const FloPayCheckout: vue.DefineComponent<vue.ExtractPropTypes<{
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    createSession: {
+        type: PropType<InlineSessionDraft>;
+        default: undefined;
+    };
+    checkoutMode: {
+        type: PropType<CheckoutMode>;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    telemetry: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    layout: {
+        type: PropType<"default" | "buttons">;
+        default: string;
+    };
+    /**
+     * React's `walletPresentation` (default `'auto'`): the preferred approval
+     * presentation for Stripe-routed PayPal, passed to the built-in form and
+     * to a custom-layout form that leaves its own unset.
+     */
+    walletPresentation: {
+        type: PropType<WalletPresentation>;
+        default: string;
+    };
+    showPayPal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showStripe: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabledPaymentMethods: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** @deprecated Session-driven visibility decides (React parity). */
+    showApplePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** @deprecated Session-driven visibility decides (React parity). */
+    showGooglePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    theme: {
+        type: PropType<ThemeId>;
+        default: undefined;
+    };
+    appearance: {
+        type: PropType<FloPayAppearance>;
+        default: undefined;
+    };
+    buttonsTheme: {
+        type: PropType<ButtonsLayoutTheme>;
+        default: undefined;
+    };
+    buttonsStyles: {
+        type: PropType<ButtonsLayoutStyles>;
+        default: undefined;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    submitLabel: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    enableAVS: {
+        type: PropType<boolean | AVSFieldConfig>;
+        default: undefined;
+    };
+    avsLayout: {
+        type: PropType<"row" | "column">;
+        default: undefined;
+    };
+    cardFieldOrder: {
+        type: PropType<VaultCardFieldKey[]>;
+        default: undefined;
+    };
+    /** @deprecated Not rendered (React parity); see {@link FloPayCheckoutProps.showSecurityFooter}. */
+    showSecurityFooter: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** @deprecated Ignored (React parity); see {@link FloPayCheckoutProps.fallbackPublishableKey}. */
+    fallbackPublishableKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    confirmLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    initialErrorMessage: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    /**
+     * React's `onBeforeButtonClick` (a function prop: its result is read),
+     * passed to the built-in `SplitCardForm`. It runs before the buttons-layout
+     * card tile opens and before PayPal creates its order.
+     */
+    onBeforeButtonClick: {
+        type: PropType<SplitCardFormBeforeButtonClick>;
+        default: undefined;
+    };
+    initialPayPalOrderId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    complete: (_result: PaymentResult) => true;
+    error: (_error: FloPayError) => true;
+    instrument: (_event: FloInstrumentEvent) => true;
+    decline: (_decline: DeclineEvent) => true;
+    buttonClick: (_method: CheckoutButtonMethod) => true;
+    countryChange: (_country: string) => true;
+    zipChange: (_zip: string) => true;
+    sessionCompleted: (_successUrl: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    sessionId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    nonce: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    createSession: {
+        type: PropType<InlineSessionDraft>;
+        default: undefined;
+    };
+    checkoutMode: {
+        type: PropType<CheckoutMode>;
+        default: undefined;
+    };
+    billingApiUrl: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    telemetry: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    locale: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    layout: {
+        type: PropType<"default" | "buttons">;
+        default: string;
+    };
+    /**
+     * React's `walletPresentation` (default `'auto'`): the preferred approval
+     * presentation for Stripe-routed PayPal, passed to the built-in form and
+     * to a custom-layout form that leaves its own unset.
+     */
+    walletPresentation: {
+        type: PropType<WalletPresentation>;
+        default: string;
+    };
+    showPayPal: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showStripe: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enabledPaymentMethods: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    /** @deprecated Session-driven visibility decides (React parity). */
+    showApplePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /** @deprecated Session-driven visibility decides (React parity). */
+    showGooglePay: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    theme: {
+        type: PropType<ThemeId>;
+        default: undefined;
+    };
+    appearance: {
+        type: PropType<FloPayAppearance>;
+        default: undefined;
+    };
+    buttonsTheme: {
+        type: PropType<ButtonsLayoutTheme>;
+        default: undefined;
+    };
+    buttonsStyles: {
+        type: PropType<ButtonsLayoutStyles>;
+        default: undefined;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    submitLabel: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    enableAVS: {
+        type: PropType<boolean | AVSFieldConfig>;
+        default: undefined;
+    };
+    avsLayout: {
+        type: PropType<"row" | "column">;
+        default: undefined;
+    };
+    cardFieldOrder: {
+        type: PropType<VaultCardFieldKey[]>;
+        default: undefined;
+    };
+    /** @deprecated Not rendered (React parity); see {@link FloPayCheckoutProps.showSecurityFooter}. */
+    showSecurityFooter: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /** @deprecated Ignored (React parity); see {@link FloPayCheckoutProps.fallbackPublishableKey}. */
+    fallbackPublishableKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    confirmLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    initialErrorMessage: {
+        type: PropType<string | null>;
+        default: null;
+    };
+    /**
+     * React's `onBeforeButtonClick` (a function prop: its result is read),
+     * passed to the built-in `SplitCardForm`. It runs before the buttons-layout
+     * card tile opens and before PayPal creates its order.
+     */
+    onBeforeButtonClick: {
+        type: PropType<SplitCardFormBeforeButtonClick>;
+        default: undefined;
+    };
+    initialPayPalOrderId: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onInstrument?: ((_event: FloInstrumentEvent) => any) | undefined;
+    onComplete?: ((_result: PaymentResult) => any) | undefined;
+    onError?: ((_error: FloPayError) => any) | undefined;
+    onDecline?: ((_decline: DeclineEvent) => any) | undefined;
+    onButtonClick?: ((_method: CheckoutButtonMethod) => any) | undefined;
+    onCountryChange?: ((_country: string) => any) | undefined;
+    onZipChange?: ((_zip: string) => any) | undefined;
+    onSessionCompleted?: ((_successUrl: string) => any) | undefined;
+}>, {
+    checkoutMode: CheckoutMode;
+    layout: "default" | "buttons";
+    nonce: string;
+    sessionId: string;
+    billingApiUrl: string;
+    telemetry: boolean;
+    debug: boolean;
+    appearance: FloPayAppearance;
+    theme: ThemeId;
+    submitLabel: string | null;
+    showPayPal: boolean;
+    walletPresentation: WalletPresentation;
+    showStripe: boolean;
+    showApplePay: boolean;
+    showGooglePay: boolean;
+    enabledPaymentMethods: string[];
+    enableAVS: boolean | AVSFieldConfig;
+    avsLayout: "column" | "row";
+    buttonsTheme: ButtonsLayoutTheme;
+    buttonsStyles: ButtonsLayoutStyles;
+    className: string;
+    cardFieldOrder: VaultCardFieldKey[];
+    onBeforeButtonClick: SplitCardFormBeforeButtonClick;
+    showSecurityFooter: boolean;
+    createSession: InlineSessionDraft;
+    locale: string;
+    fallbackPublishableKey: string;
+    confirmLabel: string;
+    initialErrorMessage: string | null;
+    initialPayPalOrderId: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Checkout state exposed by `useCheckout()`. */
+interface CheckoutState {
+    session: CheckoutSession | null;
+    loading: boolean;
+    error: FloPayError | null;
+    /** True while a detached session shell is not yet safe to charge. */
+    claimPending?: boolean;
+    /**
+     * True when the pending claim waits for a `SplitCardForm` to collect the
+     * buyer's identity (React's `claimRequiresIdentity`). A form below the
+     * checkout reads it even when its own `dataAttachmentRequiresIdentity` is
+     * unset, as React's form reads `CheckoutContext`.
+     */
+    claimRequiresIdentity?: boolean;
+    /**
+     * The inline `createSession` draft (React's `inlineSessionDraft`). A
+     * `SplitCardForm` passes it to `onBeforeButtonClick` as `createSession`.
+     */
+    inlineSessionDraft?: InlineSessionDraft;
+}
+
+/**
+ * The current `FloPay` instance as a ref: `null` while the provider's
+ * `loadFloPay()` promise is pending (or outside a `FloPayProvider`), then the
+ * instance. Read it as `useFloPay().value`.
+ */
+declare function useFloPay(): Readonly<ShallowRef<FloPay | null>>;
+/**
+ * The Stripe `FloPay` instance dedicated to the Stripe-rendered PayPal
+ * fallback, or `null` when PayPal is disabled. Direct PayPal
+ * (`gateways.paypal`) does not use this instance.
+ */
+declare function usePayPalFloPay(): Readonly<ShallowRef<FloPay | null>>;
+/**
+ * Reactive checkout state from the enclosing `FloPayCheckout`
+ * (`session`, `loading`, `error`, `claimPending`). Outside a checkout it is
+ * the same idle default the React hook returns.
+ */
+declare function useCheckout(): CheckoutState;
+
+/** Props for the `FloPayProvider` component (React's `FloPayProviderProps`, minus `children`). */
+interface FloPayProviderProps {
+    /** A `FloPay` instance or a promise that resolves to one (from `loadFloPay()`). */
+    flopay: Promise<FloPay> | FloPay | null;
+    /** Stripe `FloPay` instance for the Stripe-rendered PayPal fallback. */
+    paypalFlopay?: Promise<FloPay> | FloPay | null;
+    /** Optional provider configuration. */
+    options?: {
+        billingApiUrl?: string;
+    };
+    /** Receives the versioned, privacy-safe checkout instrument feed (`@instrument`). */
+    onInstrument?: (event: FloInstrumentEvent) => void;
+}
+/**
+ * Provides FloPay SDK state to the component tree (provide/inject). Browser
+ * work — resolving the SDK promise, telemetry, instruments — starts in
+ * `onMounted`, so server rendering renders the pending state and nothing else.
+ */
+declare const FloPayProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    flopay: {
+        type: PropType<Promise<FloPay> | FloPay | null>;
+        default: null;
+    };
+    paypalFlopay: {
+        type: PropType<Promise<FloPay> | FloPay | null>;
+        default: null;
+    };
+    options: {
+        type: PropType<{
+            billingApiUrl?: string;
+        }>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    instrument: (_event: FloInstrumentEvent) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    flopay: {
+        type: PropType<Promise<FloPay> | FloPay | null>;
+        default: null;
+    };
+    paypalFlopay: {
+        type: PropType<Promise<FloPay> | FloPay | null>;
+        default: null;
+    };
+    options: {
+        type: PropType<{
+            billingApiUrl?: string;
+        }>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onInstrument?: ((_event: FloInstrumentEvent) => any) | undefined;
+}>, {
+    flopay: FloPay | Promise<FloPay> | null;
+    paypalFlopay: FloPay | Promise<FloPay> | null;
+    options: {
+        billingApiUrl?: string;
+    };
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Props for {@link VaultCardFields} (React's `VaultCardFieldsProps`; callbacks are emits). */
+interface VaultCardFieldsProps {
+    /** The card-capture adapter (typically `useFloPay().value.cardCapture()`). */
+    capture: CardCaptureAdapter;
+    /** Server-rendered hosted vault widget HTML (the session's `vault.html`). */
+    html: string;
+    /** Per-session integrity token (the vault block's `messageToken`). */
+    messageToken?: string;
+    /** Exact origin expected for the widget's terminal `postMessage` outcomes. */
+    expectedOrigin?: string;
+    /**
+     * The form sits behind the backend's production human check (the vault
+     * block's `verification.required`, sdk#414). Forwarded to the adapter so a
+     * pre-submit frame `error` (check failed, expired or unavailable) is not
+     * reported as a vault load failure; it is still emitted as `error`.
+     */
+    verificationRequired?: boolean;
+    /** Theme colors pushed into the hosted widget live; `null` is the classic reset. */
+    theme?: VaultCardThemeColors | null;
+    /** Final, localized submit wording, applied live without a remount. */
+    submitLabel?: string | null;
+    /** Inline styles for the container the widget mounts into. */
+    containerStyle?: CSSProperties;
+}
+/**
+ * Renders the backend-served hosted vault card widget. The widget owns the
+ * card fields, the submit button, the charge and 3DS; this component only
+ * injects it through the {@link CardCaptureAdapter} (the SDK's `cardCapture`)
+ * and relays its `ready` / `error` / `validation` lifecycle as Vue events.
+ */
+declare const VaultCardFields: vue.DefineComponent<vue.ExtractPropTypes<{
+    capture: {
+        type: PropType<CardCaptureAdapter>;
+        default: undefined;
+    };
+    html: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    messageToken: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    expectedOrigin: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    verificationRequired: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    theme: {
+        type: PropType<VaultCardThemeColors | null>;
+        default: undefined;
+    };
+    submitLabel: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    containerStyle: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    ready: () => true;
+    error: (_message: string | null) => true;
+    validation: (_message: string | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    capture: {
+        type: PropType<CardCaptureAdapter>;
+        default: undefined;
+    };
+    html: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    messageToken: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    expectedOrigin: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    verificationRequired: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    theme: {
+        type: PropType<VaultCardThemeColors | null>;
+        default: undefined;
+    };
+    submitLabel: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    containerStyle: {
+        type: PropType<CSSProperties>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onError?: ((_message: string | null) => any) | undefined;
+    onReady?: (() => any) | undefined;
+    onValidation?: ((_message: string | null) => any) | undefined;
+}>, {
+    html: string;
+    theme: VaultCardThemeColors | null;
+    capture: CardCaptureAdapter;
+    messageToken: string;
+    expectedOrigin: string;
+    verificationRequired: boolean;
+    submitLabel: string | null;
+    containerStyle: CSSProperties;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { type CheckoutState, DirectPayPalButton, type DirectPayPalButtonProps, type DirectPayPalInitializationState, FloPayAutomaticPaymentButton, type FloPayAutomaticPaymentButtonProps, type FloPayAutomaticPaymentSuccessEvent, FloPayCheckout, type FloPayCheckoutProps, FloPayProvider, type FloPayProviderProps, SplitCardForm, type SplitCardFormProps, VaultCardFields, type VaultCardFieldsProps, useCheckout, useFloPay, usePayPalFloPay };