flintn-checkout 0.0.14 → 0.0.16

package/README.md

@@ -243,7 +243,8 @@ Do **not** set a fixed `height` on the container — it will leave empty space b
 |----------|------|----------|-------------|
 | `clientSessionId` | `string` | Yes | Client session ID from backend |
 | `formFields` | `FormFields` | No | Form display options — layout via `formVariant`. Field visibility and requirements are controlled by the merchant session configuration, not SDK options |
-| `styles` | `FormStyles` | No | Custom styles for the checkout form |
+| `styles` | `FormStyles` | No | Custom styles (colors, border radius, text) for the checkout form |
+| `placeholders` | `FormPlaceholders` | No | Per-field placeholder text overrides (see `FormPlaceholders`) |
 | `successRedirectUrl` | `string` | No | Redirect URL after successful payment |
 
 ### React Hook Return Values
@@ -264,7 +265,12 @@ Individual PCI-compliant input fields rendered as separate iframes. You control
 
 Each field (card number, expiry, CVV) is a separate iframe. Raw card data never touches your page.
 
-> **Note:** Hosted Fields emits only the terminal `onPayment` event — there is no `onEvent` per-attempt stream. Use Iframe Checkout if you need granular attempt analytics.
+When a card payment requires 3DS, the SDK shows the bank's challenge in a
+**modal dialog on your page**. The buyer can dismiss it, which surfaces as a
+`THREE_DS_CANCELLED` payment error. While the challenge is open, the
+`submit()` promise stays pending with a 10-minute timeout.
+
+> **Note:** For card fields, Hosted Fields emits only the terminal `onPayment` event. The express buttons additionally emit per-attempt wallet analytics via the top-level `onEvent` callback (same `onPayment` / `onEvent` split as Iframe Checkout) — see "Express buttons" below. For full per-attempt analytics across the card form too, use Iframe Checkout.
 
 **React**
 
@@ -423,6 +429,7 @@ Additional React-only options:
 | `onChange` | `(event: FieldChangeEvent) => void` | Optional additional callback |
 | `onFocus` | `(fieldType: TFieldType) => void` | Optional additional callback |
 | `onBlur` | `(fieldType: TFieldType, state: FieldState) => void` | Optional additional callback |
+| `onEvent` | `(event: ExpressAttempt) => void` | Per-attempt wallet analytics from the express buttons (see "Express buttons") |
 
 ### FieldOptions
 
@@ -438,6 +445,10 @@ Additional React-only options:
 | `cardNumberRef` | `RefObject<HTMLDivElement>` | Ref for card number container |
 | `expiryRef` | `RefObject<HTMLDivElement>` | Ref for expiry container |
 | `cvvRef` | `RefObject<HTMLDivElement>` | Ref for CVV container |
+| `applePayRef` | `RefObject<HTMLDivElement>` | Ref for the Apple Pay button container (attaching it enables the wallet) |
+| `googlePayRef` | `RefObject<HTMLDivElement>` | Ref for the Google Pay button container (attaching it enables the wallet) |
+| `payPalRef` | `RefObject<HTMLDivElement>` | Ref for the PayPal button container (attaching it enables the wallet) |
+| `expressAvailable` | `boolean` | True once wallet detection settles and at least one express button is renderable |
 | `isReady` | `boolean` | All fields loaded and ready |
 | `fieldErrors` | `Partial<Record<TFieldType, string \| null>>` | Per-field validation errors (populated after first submit) |
 | `fieldStates` | `Partial<Record<TFieldType, FieldState>>` | Per-field state (always up to date) |
@@ -478,6 +489,105 @@ Validation mirrors react-hook-form `mode: 'onSubmit'`:
 | `field.getState()` | Get current field state |
 | `field.getFieldType()` | Get the field type |
 
+### Express buttons (Apple Pay / Google Pay / PayPal)
+
+Hosted Fields can also render **fast checkout buttons** so buyers can pay with a
+wallet instead of typing card details. The buttons render **directly into your
+DOM** — one element per wallet, no iframe. Your page's own layout sizes and
+positions each button; wallet UI (the Apple Pay sheet or desktop QR modal, the
+Google Pay sheet, the PayPal popup) overlays your page natively. Only encrypted
+wallet tokens pass through the page; they are authorized against the
+session-scoped payments API, so no API key ever reaches the browser. Terminal
+results arrive through the **same `onPayment`** callback as the card `submit()`.
+
+**React**
+
+```tsx
+import { useFlintNFields } from 'flintn-checkout/react';
+
+function CheckoutForm() {
+  const {
+    cardNumberRef, expiryRef, cvvRef,
+    applePayRef, googlePayRef, payPalRef, // one container per wallet
+    expressAvailable,    // true once ≥1 wallet button is renderable
+    submit,
+  } = useFlintNFields({
+    config: { clientSessionId: 'your_client_session_id' },
+    onPayment: (result) => {
+      if (result.status === 'PAYMENT_SUCCESS') console.log('Paid:', result.data);
+    },
+    onEvent: (e) => console.log('express attempt:', e.event, e.method),
+  });
+
+  return (
+    <form onSubmit={(e) => { e.preventDefault(); submit(); }}>
+      {/* attach a ref to enable that wallet; unavailable wallets render
+          nothing — collapse empty containers via CSS if they carry spacing */}
+      <div ref={applePayRef} />
+      <div ref={googlePayRef} />
+      <div ref={payPalRef} />
+      {expressAvailable && <div className="divider">or pay by card</div>}
+
+      <div ref={cardNumberRef} style={{ height: 40 }} />
+      <div ref={expiryRef} style={{ height: 40 }} />
+      <div ref={cvvRef} style={{ height: 40 }} />
+      <button type="submit">Pay</button>
+    </form>
+  );
+}
+```
+
+**Vanilla JavaScript**
+
+```javascript
+import { createFlintNFields } from 'flintn-checkout';
+
+const fields = createFlintNFields({
+  config: { clientSessionId: 'your_client_session_id' },
+  onPayment: (result) => console.log('Payment result:', result),
+});
+
+const express = fields.createExpressButtons({
+  onCapability: (cap) => console.log('available wallets:', cap),
+  onEvent: (attempt) => console.log('express attempt:', attempt),
+});
+
+await express.mountExpressButtons([
+  { method: 'APPLE_PAY', elementSelector: '#apple-pay' },
+  { method: 'GOOGLE_PAY', elementSelector: '#google-pay' },
+  { method: 'PAYPAL', elementSelector: '#paypal' },
+]);
+
+// unmount a single wallet, or all of them
+express.unmountExpressButton('APPLE_PAY');
+express.unmountAllExpressButtons();
+
+// card fields as usual
+fields.createField('card-number').mount('#card-number');
+fields.createField('expiry').mount('#expiry');
+fields.createField('cvv').mount('#cvv');
+```
+
+Notes:
+
+- **No `submit()` for express.** Wallet buttons self-trigger (the buyer taps Apple
+  Pay and the sheet opens). Success/error come through `onPayment`; per-attempt
+  analytics through the top-level `onEvent` (React) /
+  `createExpressButtons({ onEvent })` (vanilla).
+- **Availability.** Buttons for methods that are unavailable on this
+  device/session are silently skipped at mount — their containers just stay
+  empty. `expressAvailable` (React) / the `onCapability` callback (vanilla)
+  gate your "or pay by card" divider.
+- **Which wallets appear** is driven entirely by the merchant session config
+  (`payment_methods`) intersected with device support — there is no client-side
+  allow-list.
+- **3DS** for wallet payments is handled automatically via a popup (make sure the
+  buyer's click isn't intercepted by a popup blocker).
+- **Apple Pay domain registration.** Your live domain must be registered with
+  Apple (handled during merchant onboarding) — merchant validation runs against
+  the domain the buttons render on. On non-Safari browsers Apple's JS SDK shows
+  its QR-code modal over your page. Google Pay and PayPal have no such limits.
+
 ---
 
 ## Shared Types
@@ -502,6 +612,38 @@ interface PaymentError {
 }
 ```
 
+### Error handling
+
+Errors surface through three separate channels — don't conflate them:
+
+| Channel | What lands there | Show as |
+|---------|------------------|---------|
+| `error` / `onError` | Infrastructure: SDK failed to initialize, a container is missing, the session config couldn't load | Page-level banner ("checkout unavailable / session expired") |
+| `paymentResult` / `onPayment` with `PAYMENT_ERROR` | A payment attempt failed (card or wallet) | Inline payment error, offer retry |
+| `fieldErrors` | Per-field validation (populated after the first `submit()`/`validate()`) | Messages next to each field |
+
+Common `code` values:
+
+| Code | Channel | Meaning |
+|------|---------|---------|
+| `INIT_ERROR` | error | SDK could not initialize (missing `clientSessionId`, bad `origin`) |
+| `MOUNT_ERROR` | error | A field/button container was not found or failed to mount |
+| `SESSION_EXPIRED` (and other API codes) | error or payment | Passed through from the payments API as-is |
+| `CONFIG_ERROR` | error | Session config failed to load and the API gave no code |
+| `NETWORK_ERROR` / `HTTP_<status>` / `INVALID_RESPONSE` | error or payment | Network failure / HTTP error without an API code / malformed response |
+| `VALIDATION_ERROR` | payment | `submit()` blocked by field validation (details in `fieldErrors`) |
+| `MISSING_FIELDS` / `NOT_INITIALIZED` / `SUBMIT_IN_PROGRESS` / `SUBMIT_TIMEOUT` | payment | Card `submit()` preconditions / duplicate call / no response in time (30s; 10 min during a 3DS challenge) |
+| `PAYMENT_DECLINED` / processor decline codes | payment | Declined; the processor's own code is passed through when present |
+| `PAYMENT_FAILED` | payment | Non-declined failure (including unexpected 3DS outcomes) |
+| `APPLE_PAY_SDK_ERROR` / `GOOGLE_PAY_SDK_ERROR` / `PAYPAL_ERROR` | payment | The wallet SDK failed mid-flow |
+| `PAYPAL_MISSING_PAYMENT_ID` | payment | PayPal approved but no payment id was captured (anomaly) |
+| `THREE_DS_FAILED` / `THREE_DS_CANCELLED` | payment | Challenge declined / dismissed by the buyer |
+| `THREE_DS_POPUP_BLOCKED` | payment | Express buttons only — the wallet 3DS window was blocked by the browser |
+
+Worth handling specifically: `SESSION_EXPIRED` (create a fresh session and remount),
+`THREE_DS_POPUP_BLOCKED` (ask the buyer to allow popups), `VALIDATION_ERROR`
+(highlight fields from `fieldErrors`). Everything else is safely generic.
+
 ### CheckoutEvent
 
 ```typescript
@@ -619,8 +761,13 @@ interface FormStyles {
   inputBorderHoverColor?: string;
   inputBorderFocusColor?: string;
   inputBorderErrorColor?: string;
+  inputTextColor?: string;
+  inputFontSize?: string;
+  inputHeight?: string;
+  placeholderColor?: string;
   errorMessageColor?: string;
   labelColor?: string;
+  labelFontSize?: string;
   dividerColor?: string;
   dividerTextColor?: string;
   safeCheckoutAccentColor?: string;
@@ -637,6 +784,8 @@ interface FormStyles {
   buttonColor?: string;
   buttonHoverColor?: string;
   buttonBorderRadius?: string;
+  buttonHeight?: string;
+  buttonFontSize?: string;
   buttonText?: string;
   cardButtonColor?: string;
   cardButtonHoverColor?: string;
@@ -644,6 +793,30 @@ interface FormStyles {
 }
 ```
 
+### FormPlaceholders
+
+```typescript
+interface FormPlaceholders {
+  email?: string;
+  cardNumber?: string;
+  expiry?: string;
+  cvv?: string;
+  cardholderName?: string;
+  addressLine1?: string;
+  addressLine2?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  country?: string;
+}
+```
+
+Per-field placeholder text overrides for the **iframe checkout** form, passed as
+`config.placeholders` (not under `styles` — placeholder text is field content, not
+visual styling). Any field left undefined keeps its built-in default placeholder.
+For **hosted fields**, set placeholder text per field via the `placeholder` option
+on `createField` (or the `fields` prop of `useFlintNFields`) instead.
+
 ### FormStyles Reference
 
 | Property | Iframe Checkout | Hosted Fields | Description |
@@ -651,16 +824,21 @@ interface FormStyles {
 | `loaderColor` | ✅ | — | Loading spinner color |
 | `backgroundColor` | ✅ | — | Form background color |
 | `lightLogos` | ✅ | — | Use light logo variants in the safe-checkout row (for dark backgrounds) |
-| `expressButtonsSpacing` | ✅ | — | Spacing between express payment buttons |
-| `expressButtonsBorderRadius` | ✅ | — | Corner radius for express buttons — Apple Pay, Google Pay, PayPal, and the "Credit or debit card" button in the LIST variant (e.g. `8px`) |
+| `expressButtonsSpacing` | ✅ | — | Spacing between express payment buttons. Not applicable to Hosted Fields — the buttons render into your own containers, so spacing is your page's layout |
+| `expressButtonsBorderRadius` | ✅ | ✅ | Corner radius for express buttons — Apple Pay, Google Pay, PayPal, and the "Credit or debit card" button in the LIST variant (e.g. `8px`). In Hosted Fields it applies to all wallet buttons at once |
 | `inputBackgroundColor` | ✅ | ✅ | Input field background color |
 | `inputBorderRadius` | ✅ | ✅ | Input field border radius |
 | `inputBorderColor` | ✅ | ✅ | Default input border color |
 | `inputBorderHoverColor` | ✅ | ✅ | Input border color on hover |
 | `inputBorderFocusColor` | ✅ | ✅ | Input border color on focus |
 | `inputBorderErrorColor` | ✅ | ✅ | Input border color in error state |
+| `inputTextColor` | ✅ | ✅ | Input text (typed value) color |
+| `inputFontSize` | ✅ | ✅ | Input text font size (e.g. `16px`) |
+| `inputHeight` | ✅ | ✅ | Total input field height, border included (e.g. `48px`; default `40px`) |
+| `placeholderColor` | ✅ | ✅ | Input placeholder text color |
 | `errorMessageColor` | ✅ | — | Error message text color |
 | `labelColor` | ✅ | — | Field label text color |
+| `labelFontSize` | ✅ | — | Field label font size (e.g. `14px`) |
 | `dividerColor` | ✅ | — | Divider line color ("or" + "safe checkout" dividers) |
 | `dividerTextColor` | ✅ | — | "or" divider text color |
 | `safeCheckoutAccentColor` | ✅ | — | "Safe" accent word color (defaults to theme success) |
@@ -677,6 +855,8 @@ interface FormStyles {
 | `buttonColor` | ✅ | — | Submit button background color |
 | `buttonHoverColor` | ✅ | — | Submit button hover color |
 | `buttonBorderRadius` | ✅ | — | Submit button border radius |
+| `buttonHeight` | ✅ | — | Submit button height (e.g. `48px`; default `40px`) |
+| `buttonFontSize` | ✅ | — | Submit button text font size (e.g. `16px`; default `14px`) |
 | `buttonText` | ✅ | — | Custom submit button text |
 | `cardButtonColor` | ✅ | — | Card button color (LIST variant) |
 | `cardButtonHoverColor` | ✅ | — | Card button hover color (LIST variant) |
@@ -715,6 +895,7 @@ Every cancellation still emits a `CANCELLED` `onEvent` regardless of variant, so
 
 ### Hosted Fields
 - Credit/Debit Cards (Visa, Mastercard, Amex, Discover)
+- Apple Pay, Google Pay, PayPal (via the express buttons — see "Express buttons" above)
 
 ## Debug Mode
 

package/dist/index.d.mts

@@ -20,6 +20,19 @@ type TCheckoutFormVariant = (typeof CheckoutFormVariant)[keyof typeof CheckoutFo
 interface FormFields {
     formVariant?: TCheckoutFormVariant;
 }
+interface FormPlaceholders {
+    email?: string;
+    cardNumber?: string;
+    expiry?: string;
+    cvv?: string;
+    cardholderName?: string;
+    addressLine1?: string;
+    addressLine2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+}
 interface FormStyles {
     loaderColor?: string;
     backgroundColor?: string;
@@ -32,8 +45,13 @@ interface FormStyles {
     inputBorderHoverColor?: string;
     inputBorderFocusColor?: string;
     inputBorderErrorColor?: string;
+    inputTextColor?: string;
+    inputFontSize?: string;
+    inputHeight?: string;
+    placeholderColor?: string;
     errorMessageColor?: string;
     labelColor?: string;
+    labelFontSize?: string;
     dividerColor?: string;
     dividerTextColor?: string;
     safeCheckoutAccentColor?: string;
@@ -50,6 +68,8 @@ interface FormStyles {
     buttonColor?: string;
     buttonHoverColor?: string;
     buttonBorderRadius?: string;
+    buttonHeight?: string;
+    buttonFontSize?: string;
     buttonText?: string;
     cardButtonColor?: string;
     cardButtonHoverColor?: string;
@@ -59,6 +79,7 @@ interface FlintNConfig {
     clientSessionId: string;
     formFields?: FormFields;
     styles?: FormStyles;
+    placeholders?: FormPlaceholders;
     successRedirectUrl?: string;
 }
 declare const PaymentMethod: {
@@ -150,6 +171,8 @@ declare const FieldEventType: {
     readonly FIELD_VALIDATION: "FIELD_VALIDATION";
     readonly FIELD_SUBMIT_RESULT: "FIELD_SUBMIT_RESULT";
     readonly FIELD_HEIGHT: "FIELD_HEIGHT";
+    readonly FIELD_THREE_DS_REQUIRED: "FIELD_THREE_DS_REQUIRED";
+    readonly FIELD_THREE_DS_RESULT: "FIELD_THREE_DS_RESULT";
 };
 type TFieldEventType = (typeof FieldEventType)[keyof typeof FieldEventType];
 interface FieldOptions {
@@ -179,8 +202,31 @@ interface FieldsValidationResult {
     isValid: boolean;
     errors: Partial<Record<TFieldType, string | null>>;
 }
+interface SubmitBillingAddress {
+    addressLine1?: string;
+    addressLine2?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+}
 interface SubmitOptions {
     cardholderName?: string;
+    email?: string;
+    billingAddress?: SubmitBillingAddress;
+}
+interface ExpressCapability {
+    applePay: boolean;
+    googlePay: boolean;
+    paypal: boolean;
+}
+interface ExpressAttempt {
+    event: TPaymentAttemptResult;
+    method: TPaymentMethod;
+    paymentId?: string;
+    code?: string;
+    message?: string;
+    timestamp: number;
 }
 interface FlintNFieldsConfig {
     clientSessionId: string;
@@ -226,9 +272,144 @@ interface FlintNField {
 }
 declare function createFlintNField(fieldType: TFieldType, origin: string, clientSessionId: string, options: FieldOptions, callbacks: FlintNFieldInternalCallbacks, debug?: boolean, formStyles?: FormStyles): FlintNField;
 
+declare const EXPRESS_BUTTON_HEIGHT = 40;
+declare const ExpressMethod: {
+    readonly APPLE_PAY: "APPLE_PAY";
+    readonly GOOGLE_PAY: "GOOGLE_PAY";
+    readonly PAYPAL: "PAYPAL";
+};
+type TExpressMethod = (typeof ExpressMethod)[keyof typeof ExpressMethod];
+/** One entry per wallet button: which method goes into which element. */
+interface ExpressButtonMount {
+    method: TExpressMethod;
+    /** CSS selector or the element itself. The button fills the element. */
+    elementSelector: string | HTMLElement;
+}
+interface FlintNExpressButtonsOptions {
+    config: {
+        clientSessionId: string;
+    };
+    origin?: string;
+    apiUrl?: string;
+    buttonBorderRadius?: number;
+    onPayment?: (result: PaymentResult) => void;
+    onEvent?: (event: ExpressAttempt) => void;
+    onCapability?: (capability: ExpressCapability) => void;
+    onError?: (error: PaymentError) => void;
+    debug?: boolean;
+}
+interface FlintNExpressButtons {
+    mountExpressButtons(buttons: ExpressButtonMount[]): Promise<void>;
+    unmountExpressButton(method: TExpressMethod): void;
+    unmountAllExpressButtons(): void;
+}
+interface ApplePayConfig {
+    country_code: string;
+    supported_networks: string[];
+    merchant_capabilities: string[];
+    display_name: string;
+    merchant_identifier?: string;
+}
+interface GooglePayConfig {
+    environment: string;
+    gateway: string;
+    gateway_merchant_id: string;
+    merchant_id?: string;
+    merchant_name?: string;
+    country_code?: string;
+}
+interface PayPalConfig {
+    client_id: string;
+    merchant_id?: string;
+}
+interface SessionConfig {
+    session: {
+        amount: number;
+        currency_code: string;
+    };
+    payment_methods: string[];
+    apple_pay_config?: ApplePayConfig;
+    google_pay_config?: GooglePayConfig;
+    paypal_config?: PayPalConfig;
+}
+declare const AuthorizedStatus: {
+    readonly PENDING: "PENDING";
+    readonly AUTHORIZED: "AUTHORIZED";
+    readonly FAILED: "FAILED";
+    readonly DECLINED: "DECLINED";
+    readonly THREE_DS_INITIATED: "THREE_DS_INITIATED";
+};
+type TAuthorizedStatus = (typeof AuthorizedStatus)[keyof typeof AuthorizedStatus];
+interface AuthorizeResponse {
+    id: string;
+    status: TAuthorizedStatus;
+    required_action?: {
+        type: string;
+        redirect_url: string;
+    };
+    status_reason?: {
+        decline_reason?: string;
+        message?: string;
+    };
+}
+interface ApplePayToken {
+    payment_data: {
+        data: string;
+        header: {
+            ephemeral_public_key: string;
+            public_key_hash: string;
+            transaction_id: string;
+        };
+        signature: string;
+        version: string;
+    };
+    payment_method: {
+        display_name: string;
+        network: string;
+        type: string;
+    };
+    transaction_identifier: string;
+}
+interface GooglePayToken {
+    token: string;
+}
+/** Terminal-ish callbacks the wallet flows report into (mirrors the iframe's ExpressAuthorizeHandlers). */
+interface WalletAuthorizeHandlers {
+    onAuthorized: (paymentId: string) => void;
+    onThreeDs: (redirectUrl: string, paymentId: string) => void;
+    onFailed: (code: string, message: string, paymentId?: string) => void;
+}
+
+/**
+ * Express fast-checkout buttons (Apple Pay / Google Pay / PayPal) rendered
+ * DIRECTLY into the merchant's DOM — one element per wallet, Yuno-style.
+ * There is no iframe: wallet SDKs load on the merchant page, wallet UI
+ * (Apple Pay QR modal, payment sheets) overlays the page natively, and the
+ * page's own layout sizes the buttons. Only encrypted wallet tokens pass
+ * through the page; they are authorized against the session-scoped payments
+ * API (no API key in the browser).
+ */
+declare function createFlintNExpressButtons(options: FlintNExpressButtonsOptions): FlintNExpressButtons;
+
+declare const deriveApiUrl: (payOrigin: string) => string;
+
+/**
+ * Per-instance express options; session/origin/onPayment come from the fields
+ * instance, and button styling comes from `config.styles`
+ * (expressButtonsBorderRadius).
+ */
+type ExpressButtonsOptions = Pick<FlintNExpressButtonsOptions, 'apiUrl' | 'onEvent' | 'onCapability'>;
 interface FlintNFields {
     createField(fieldType: TFieldType, options?: FieldOptions): FlintNField;
     getField(fieldType: TFieldType): FlintNField | undefined;
+    /**
+     * Create the express fast-checkout buttons (Apple Pay / Google Pay /
+     * PayPal), rendered directly into merchant-owned elements (one per wallet —
+     * see `mountExpressButtons`). Terminal results flow through the same
+     * `onPayment` callback as the card `submit()`; per-attempt analytics and
+     * capability flags are delivered via the options passed here.
+     */
+    createExpressButtons(options?: ExpressButtonsOptions): FlintNExpressButtons;
     validate(): Promise<FieldsValidationResult>;
     submit(options?: SubmitOptions, skipValidation?: boolean): Promise<PaymentResult>;
     unmount(): void;
@@ -244,4 +425,4 @@ declare const validateConfig: (config: {
 }) => void;
 declare const sanitizeToken: (token: string) => string;
 
-export { type CheckoutEvent, CheckoutFormVariant, CheckoutView, EventType, type FieldChangeEvent, FieldEventType, type FieldOptions, type FieldState, FieldType, type FieldValidationResult, type FieldsValidationResult, type FlintNConfig, type FlintNField, type FlintNFieldInternalCallbacks, type FlintNFields, type FlintNFieldsConfig, type FlintNFieldsOptions, type FlintNPayment, type FlintNPaymentOptions, type FormFields, type FormStyles, type PaymentAttempt, PaymentAttemptResult, type PaymentError, PaymentMethod, type PaymentResult, type PaymentUI, PaymentUIEvent, type SubmitOptions, type TCheckoutFormVariant, type TCheckoutView, type TEventType, type TFieldEventType, type TFieldType, type TPaymentAttemptResult, type TPaymentMethod, type TPaymentUIEvent, buildIframeSrc, createFlintNField, createFlintNFields, createFlintNPayment, createIframeElement, isAttemptEvent, isUIEvent, parseOrigin, sanitizeToken, validateConfig };
+export { type ApplePayConfig, type ApplePayToken, type AuthorizeResponse, AuthorizedStatus, type CheckoutEvent, CheckoutFormVariant, CheckoutView, EXPRESS_BUTTON_HEIGHT, EventType, type ExpressAttempt, type ExpressButtonMount, type ExpressButtonsOptions, type ExpressCapability, ExpressMethod, type FieldChangeEvent, FieldEventType, type FieldOptions, type FieldState, FieldType, type FieldValidationResult, type FieldsValidationResult, type FlintNConfig, type FlintNExpressButtons, type FlintNExpressButtonsOptions, type FlintNField, type FlintNFieldInternalCallbacks, type FlintNFields, type FlintNFieldsConfig, type FlintNFieldsOptions, type FlintNPayment, type FlintNPaymentOptions, type FormFields, type FormPlaceholders, type FormStyles, type GooglePayConfig, type GooglePayToken, type PayPalConfig, type PaymentAttempt, PaymentAttemptResult, type PaymentError, PaymentMethod, type PaymentResult, type PaymentUI, PaymentUIEvent, type SessionConfig, type SubmitBillingAddress, type SubmitOptions, type TAuthorizedStatus, type TCheckoutFormVariant, type TCheckoutView, type TEventType, type TExpressMethod, type TFieldEventType, type TFieldType, type TPaymentAttemptResult, type TPaymentMethod, type TPaymentUIEvent, type WalletAuthorizeHandlers, buildIframeSrc, createFlintNExpressButtons, createFlintNField, createFlintNFields, createFlintNPayment, createIframeElement, deriveApiUrl, isAttemptEvent, isUIEvent, parseOrigin, sanitizeToken, validateConfig };