tf-checkout-react 1.7.31 → 2.0.0-beta.0

package/dist/index.d.mts

@@ -0,0 +1,3930 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import React, { FC, CSSProperties, ReactNode, HTMLAttributes, ButtonHTMLAttributes, InputHTMLAttributes, SelectHTMLAttributes, TextareaHTMLAttributes } from 'react';
+import { StripeCardElementOptions, StripePaymentElementOptions, StripeCardElement, StripeElements, Stripe } from '@stripe/stripe-js';
+
+/**
+ * The one platform seam the SDK's transport needs: somewhere to keep tokens.
+ *
+ * Web passes a `localStorage`-backed adapter, React Native an MMKV-backed one.
+ * If a consumer configures nothing, we fall back to an in-memory map so the SDK
+ * still works in tests and SSR (tokens just don't survive a reload).
+ *
+ * Deliberately synchronous — web `localStorage` and RN MMKV are both sync, and
+ * a sync contract keeps the axios interceptors trivial. If you only have an
+ * async store (AsyncStorage), wrap it with a small sync mirror.
+ */
+interface StorageAdapter {
+    getItem(key: string): string | null | undefined;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/** Process-lifetime fallback store. Not persisted — good enough for tests/SSR. */
+declare const createMemoryStorage: () => StorageAdapter;
+
+/**
+ * One-time setup for the SDK. Call `configure()` at app start, before any
+ * `ttf.*` call or hook runs. Everything downstream (transport, session, api)
+ * reads this single record — there is no other global state.
+ */
+
+type TtfEnv = 'PROD' | 'STAG' | 'DEV';
+/**
+ * Extra auth material the consumer hands us — called on EVERY request; whatever
+ * headers it returns are merged in last (they win over the SDK's own). Pass a
+ * bearer token, a session cookie, an API key — anything. This is the flexible
+ * "bring your own auth" seam. Return `undefined` to add nothing this request.
+ */
+type AuthProvider = () => Record<string, string> | undefined;
+interface TtfConfig {
+    /** Host origin, e.g. `https://www.ticketfairy.com` — the `/api` path is
+     *  appended internally. `''` = same-origin. Omit to use `env`. */
+    baseUrl?: string;
+    /** Picks the TicketFairy host when `baseUrl` is omitted. Defaults to PROD. */
+    env?: TtfEnv;
+    /** OAuth client id issued to your brand. */
+    clientId: string;
+    /** OAuth client secret issued to your brand. */
+    clientSecret: string;
+    /** Value for the `X-Source-Origin` header (your domain). Optional. */
+    sourceOrigin?: string;
+    /** Where tokens live. Defaults to an in-memory store (not persisted). */
+    storage?: StorageAdapter;
+    /** Bring-your-own auth: return headers to attach to every request (token,
+     *  cookie, custom). Merged last, so it overrides the SDK's own headers. */
+    auth?: AuthProvider;
+    /** Cookie-based session auth: forward the `X-TF-ECOMMERCE` login ticket (+
+     *  browser cookies where they exist) as headers, and capture the rotating
+     *  ones back from responses. Sign-in rides the legacy `/auth` session flow —
+     *  no bearer is minted, so the backend session that holds a reserved cart
+     *  survives a mid-checkout login. Enable when the app shares a session cookie
+     *  with TicketFairy (same-domain / SSO), runs anonymous cookie carts, or is a
+     *  native app (React Native persists the ticket via the storage adapter —
+     *  the RN `configureCheckout` turns this on by default). */
+    cookieAuth?: boolean;
+}
+/** Fully-resolved config — `storage`, `host`, and `apiBaseUrl` always present. */
+interface ResolvedTtfConfig extends TtfConfig {
+    storage: StorageAdapter;
+    /** Host origin, no `/api` (e.g. `https://www.ticketfairy.com`). '' = same-origin. */
+    host: string;
+    /** The transport base: `<host>/api`. */
+    apiBaseUrl: string;
+}
+/** Wire the SDK. Idempotent — the last call wins. */
+declare const configure: (config: TtfConfig) => void;
+/** True once `configure()` has run. Lets callers branch without catching. */
+declare const isConfigured: () => boolean;
+
+declare class TtfError extends Error {
+    /** HTTP status, or 0 for network/transport failures. */
+    readonly status: number;
+    /** Backend error code when present (e.g. `INVALID_CREDENTIALS`). */
+    readonly code?: string;
+    /** The raw payload, for callers that need more than the message. */
+    readonly data?: unknown;
+    constructor(message: string, status: number, code?: string, data?: unknown);
+}
+
+declare const getAccessToken: () => string | null;
+declare const getGuestToken: () => string | null;
+declare const clearSession: () => void;
+/**
+ * True when a signed-in access token is present. Cookie-enabled web consumers
+ * also recognize an existing legacy storefront session during migration.
+ */
+declare const isAuthenticated: () => boolean;
+
+/**
+ * Public types shared across api domains. Domain-specific request/response
+ * shapes live next to their api function; this file holds only what more than
+ * one domain needs (the backend envelopes, the profile record, geo).
+ */
+/** The envelope the platform wraps single-object responses in. */
+interface TfEnvelope<T> {
+    data: T;
+    success?: boolean;
+    message?: string;
+    status?: number;
+    error?: boolean;
+}
+/** The envelope list endpoints use: rows nested under `data.attributes`. */
+interface TfListEnvelope<T> {
+    data: {
+        attributes: T[];
+        id?: string;
+        type?: string;
+    };
+    meta?: {
+        total?: number;
+        page?: number;
+        limit?: number;
+        [key: string]: unknown;
+    };
+}
+interface TfTicketHolder {
+    firstName: string | null;
+    lastName: string | null;
+    phone: string | null;
+    email: string | null;
+}
+/** The signed-in user's profile (mirrors the platform `IProfileData`). */
+interface TfProfile {
+    id: number | string;
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone?: string;
+    streetAddress?: string;
+    zipCode?: string | number;
+    countryId: string | number;
+    company: string | null;
+    stateId?: string | number;
+    city?: string;
+    username: string;
+    screenName: string | null;
+    bio: string | null;
+    shortBio: string | null;
+    region: string | null;
+    image: string | null;
+    recommendedEvents: unknown[];
+    rnRoles: string[];
+    hasDashboardAccess: boolean;
+    ticketHolders: TfTicketHolder[];
+    linkedCryptoWallets: string[];
+}
+interface TfCountry {
+    id: string | number;
+    name: string;
+    code?: string;
+}
+interface TfState {
+    id: string | number;
+    name: string;
+    code?: string;
+}
+
+type Id = string | number;
+
+/**
+ * THE endpoint registry — every path the SDK calls, in one place, grouped by
+ * domain to mirror `api/`, `dtos/`, and the `ttf` facade. No api function spells
+ * a URL inline; they all read from here.
+ *
+ * Conventions:
+ * - Paths are relative to the transport base (`<host>/api`) — see `client/http`.
+ *   A few legacy endpoints live off `/api` (`event/:id/time-slot-by-date`,
+ *   `event/:id/reservation/refresh/`); those omit the `v1/` prefix on purpose.
+ * - `auth.contactEmail` is origin-rooted (NOT under `/api`) — it's joined with
+ *   `getOriginUrl()` at the call site.
+ * - Static resources are string constants; parameterized ones are builder
+ *   functions that take the id/hash. Dynamic query params (pagination, filters)
+ *   are appended by the api function — only canonical flags that ARE the
+ *   endpoint (`?payment_config=1`) are baked in here.
+ */
+
+declare const ENDPOINTS: {
+    /** OAuth login, registration, password recovery, and identity verification. */
+    readonly auth: {
+        /** OAuth step 1 — exchange email+password for an authorization code. */
+        readonly authorizeRn: (clientId: Id) => string;
+        /** OAuth step 2 — exchange the code for an access token. */
+        readonly accessToken: "v1/oauth/access_token";
+        /** Create an account (multipart form data). */
+        readonly registerRn: "v1/oauth/register-rn";
+        /** Cookie session — `DELETE` to sign out. */
+        readonly session: "/auth";
+        /** Request a "forgot password" email (web). */
+        readonly restorePassword: "/auth/restore-password";
+        /** Request a "forgot password" email (React Native variant). */
+        readonly restorePasswordRn: "v1/oauth/restore-password-rn";
+        /** Complete a password reset with the token from the email. */
+        readonly resetPassword: "/auth/reset-password";
+        /** Existing-account lookup — ORIGIN-rooted + form-encoded, NOT under /api.
+         *  Joined with `getOriginUrl()` at the call site. */
+        readonly contactEmail: "ajax/contact-email/";
+        /** Read the signed-in user's identity-verification status (Netverify). */
+        readonly verificationInfo: "v1/authenticate/get-verification-info";
+        /** `GET` mints the hosted verification URL; `PATCH` marks it PENDING. */
+        readonly verify: "v1/authenticate/verify";
+    };
+    /** The signed-in user's profile. */
+    readonly profile: {
+        readonly get: "/customer/profile/";
+    };
+    /** Billing-select geography. */
+    readonly geo: {
+        /** All selectable countries. */
+        readonly countries: "/countries/list";
+        /** States/provinces for a country (id→name map). */
+        readonly states: (countryId: Id) => string;
+    };
+    /** Event catalog + engagement — everything keyed by an event id. */
+    readonly events: {
+        /** `GET v1/event/:id` — event details (seated detection, slug, name). */
+        readonly info: (eventId: Id) => string;
+        /** Purchasable ticket types (+ promo/waiting-list metadata). */
+        readonly tickets: (eventId: Id) => string;
+        /** Ticket types for one date of a time-slot event (legacy, off /api). */
+        readonly timeSlotByDate: (eventId: Id) => string;
+        /** Event add-ons. */
+        readonly addOns: (eventId: Id) => string;
+        /** Custom-field groups (order / ticket / add-on scopes). */
+        readonly customFields: (eventId: Id) => string;
+        /** Terms/conditions the buyer may need to accept. */
+        readonly conditions: (eventId: Id) => string;
+        /** Apply a promo/access code to the session. */
+        readonly promo: (eventId: Id) => string;
+        /** Session currency preference (multi-currency events). */
+        readonly currency: (eventId: Id) => string;
+        /** Unlock a password-protected event. */
+        readonly authenticate: (eventId: Id) => string;
+        /** Tracking pixel (page view / order attribution). */
+        readonly track: (eventId: Id) => string;
+        /** Write ORDER-level custom-field values after the order exists. */
+        readonly orderDataCapture: (eventId: Id) => string;
+        /** Write TICKET-level (per-holder) custom-field values. */
+        readonly ticketDataCapture: (eventId: Id) => string;
+        /** Attribute the session to a referrer/promoter. */
+        readonly referrer: (eventId: Id) => string;
+        /** Join the sold-out waiting list. */
+        readonly waitingList: (eventId: Id) => string;
+        /** Submit RSVP details. */
+        readonly rsvp: (eventId: Id) => string;
+    };
+    /** Cart + pricing session. */
+    readonly cart: {
+        /** Read the cart back (pins the event's payment method into the session). */
+        readonly get: "v1/cart/";
+        /** Cart + pre-order payment config (identifies the gateway pre-order). */
+        readonly withPaymentConfig: "v1/cart?payment_config=1";
+        /** Cart + display-ready server price breakdown; optional add-on query. */
+        readonly withPriceBreakdown: (addOnsQuery?: string) => string;
+        /** Replace the whole cart with the current ticket selection. */
+        readonly addToCart: (eventId: Id) => string;
+        /** Price the cart (+ add-ons). */
+        readonly checkout: "v1/checkout";
+        /** Checkout gates for the current session (names_required, field gates). */
+        readonly checkoutConfigs: "v1/checkout-configs";
+        /** Payment-plan charge by explicit payment method (saved-card shortcut). */
+        readonly paymentPlan: (orderHash: string) => string;
+    };
+    /** Order lifecycle — create, review, finalize. */
+    readonly order: {
+        /** Create the order from buyer + holders + add-ons (the on-checkout body). */
+        readonly create: "v1/on-checkout/";
+        /** Post-order review — gateway identity + Stripe/plan secrets + totals. */
+        readonly review: (orderHash: string) => string;
+        /** Finalize a paid/pending order (emails receipt/voucher, defers webhook). */
+        readonly success: (orderHash: string) => string;
+        /** Complete a free (zero-total) registration. */
+        readonly completeFreeRegistration: (orderHash: string) => string;
+        /** Guard: does the signed-in user own this order hash. */
+        readonly verifyCustomer: (orderHash: string) => string;
+        /** ID-verification round trip (`?url=1` mints the provider session URL). */
+        readonly idVerification: (orderHash: string, mintUrl?: boolean) => string;
+        /** Confirmation-page payload for a completed order. */
+        readonly confirmation: (orderHash: string) => string;
+    };
+    /** Payment rails — the per-gateway wire after the order exists. */
+    readonly payment: {
+        /** Xendit charges (e-wallets AND cards) — form-encoded, not JSON:API. */
+        readonly submitPayment: (orderHash: string) => string;
+        /** OXXO: move the order to the pending-voucher state before the confirm. */
+        readonly prepareOxxo: (orderHash: string) => string;
+        /** Per-payment-method-type fee re-price (re-fetch the review after). */
+        readonly methodType: (orderHash: string) => string;
+        /** MSI installment offers (between PM creation and the confirm). */
+        readonly installmentOffers: (orderHash: string) => string;
+        /** MSI confirm (server-side; follow with handleNextAction only). */
+        readonly confirmInstallments: (orderHash: string) => string;
+        /** PayPal Standard step 1 — switch the placed order's method. */
+        readonly changeMethod: "v1/change-payment-method";
+        /** PayPal Standard step 2 — the {action_url, fields} to top-level POST. */
+        readonly paypalForm: (orderHash: string) => string;
+        /** Server-side confirm for redirect-based Stripe methods. */
+        readonly confirmRedirect: (orderHash: string) => string;
+        /** Schedule a payment plan against a new card's PaymentMethod. */
+        readonly paymentPlanCreate: (orderHash: string) => string;
+    };
+    /** Account — the buyer's own orders and tickets. */
+    readonly account: {
+        /** Order history (server-paginated; caller appends page/limit/filter query). */
+        readonly orders: "v1/account/orders/";
+        /** One order's full detail. */
+        readonly order: (orderId: Id) => string;
+        /** The buyer's tickets/wallet (caller appends the query). */
+        readonly tickets: "v1/account/tickets/";
+        /** Twilio-backed phone validation. */
+        readonly validatePhone: (phone: string) => string;
+    };
+    /** Ticket resale. */
+    readonly resale: {
+        readonly sell: (ticketId: Id) => string;
+        readonly process: (ticketId: Id) => string;
+        readonly decline: (ticketId: Id) => string;
+    };
+    /** Pre-registration ("register interest, then share"). */
+    readonly preRegistration: {
+        /** Confirm pre-registration for an event. */
+        readonly confirm: (eventId: Id) => string;
+        /** Influencers/promoters available to share to. */
+        readonly influencers: (eventId: Id) => string;
+        /** The post-confirm share page (options + current standing). */
+        readonly confirmationPage: (hash: string) => string;
+        /** Record a share action (a referral phase step). */
+        readonly submitAction: (hash: string) => string;
+    };
+    /** Guest ticket delegation (claim a ticket via an access link). */
+    readonly delegation: {
+        /** Whether the recipient already has an account. */
+        readonly customerExists: (accessHash: string) => string;
+        /** The claim page (event + ticket context). */
+        readonly consumerPageInfo: (accessHash: string) => string;
+        /** Issue (claim) the delegated ticket. */
+        readonly issueTicket: (accessHash: string) => string;
+    };
+    /** Seated events — the seat picker's wire. */
+    readonly seatmap: {
+        /** The venue seat map. */
+        readonly data: (eventId: Id) => string;
+        /** Live seat statuses (poll during selection). */
+        readonly statuses: (eventId: Id) => string;
+        /** Reserve a seat selection. */
+        readonly reserve: (eventId: Id) => string;
+        /** Release a held reservation. */
+        readonly deleteReserved: (eventId: Id) => string;
+        /** Extend a reservation's TTL (legacy, off /api). */
+        readonly refreshReservation: (eventId: Id) => string;
+    };
+};
+/** The `ENDPOINTS` shape, for callers that want to type against it. */
+type Endpoints = typeof ENDPOINTS;
+
+/**
+ * Gateway-level constant sets: which Stripe payment-method types re-price the
+ * order, and the Xendit processor rules. Pure data — the logic that reads them
+ * lives in `logic/`.
+ */
+/** Non-single-charge Stripe payment modes: every type here re-prices the order
+ *  before the client confirm. Card and wallet payments stay single_charge and
+ *  skip the call. */
+declare const FEE_MODE_PAYMENT_METHOD_TYPES: ReadonlySet<string>;
+/** Xendit wallet keys that need one extra buyer-typed field before charging. */
+declare const XENDIT_EWALLET_EXTRA_FIELD: Readonly<Record<string, string>>;
+/** Xendit selector rows that are NOT one-tap e-wallet charges (cards tokenize
+ *  client-side, bank transfers issue virtual accounts) — filter these out when
+ *  offering the wallet buttons. */
+declare const XENDIT_NON_EWALLET_PROCESSORS: ReadonlySet<string>;
+
+/**
+ * Redirect-based Stripe payment methods (Klarna/Afterpay/Affirm/iDEAL-class)
+ * the WebView/popup round trip supports, keyed by the server's
+ * payment_method_types spelling.
+ */
+declare const SUPPORTED_REDIRECT_METHODS: ReadonlySet<string>;
+/** Filters a server `paymentMethodTypes` list to the redirect methods the flow
+ *  supports (order preserved, unknown types dropped). */
+declare const listRedirectMethods: (paymentMethodTypes?: string[] | null) => string[];
+
+/**
+ * Event catalog shapes — tickets, add-ons, conditions, custom fields, buyer
+ * gates, currency. What the `events` api returns and the checkout UI renders.
+ */
+/** A purchasable ticket type, normalized from the tickets endpoint. */
+interface TicketType {
+    /** Encrypted ticket id — opaque; pass back verbatim in a TicketSelection. */
+    id: string;
+    name: string;
+    /** Optional catalog grouping shown as a heading above adjacent ticket types. */
+    groupName?: string | null;
+    /** Option key (e.g. "ticket_type") the cart payload needs. */
+    optionName: string;
+    price: number;
+    /** Price WITH booking fees added (the wire's `basePrice`) — shown as the
+     *  "(… with fees)" sub-line. Equals `price` when the event has no fees. */
+    priceWithFees: number;
+    /** Display currency symbol from the wire (e.g. "₹", "US$"). Prefer this over
+     *  the ISO `currency` code for rendering money the way the old checkout did. */
+    priceSymbol: string;
+    currency: string;
+    feeIncluded: boolean;
+    /** Deposit percentage for a table/deposit ticket (e.g. 50, 100), else null —
+     *  rendered as "50% DEPOSIT". */
+    depositPercent: number | null;
+    soldOut: boolean;
+    /** Sales window has OPENED. `false` → "Sales not started"; combined with
+     *  `salesEnded` it distinguishes not-yet-on-sale from closed. */
+    salesStarted: boolean;
+    salesEnded: boolean;
+    minQuantity: number;
+    maxQuantity: number;
+    /** Step between selectable quantities (the old checkout's `multiplier`) — the
+     *  cart sells this type in blocks of N, so options run min, min+step, … Almost
+     *  always 1. */
+    multiplier: number;
+    /** This type is a table: the quantity control picks the number of GUESTS at
+     *  the table (bounded by `minGuests`/`maxGuests`), not a count of tickets. The
+     *  chosen guest count is what the cart quantity carries. */
+    isTable: boolean;
+    /** Table only — the fewest guests the table may be booked for (its real floor;
+     *  e.g. a "full table" forces the minimum). Ignore for non-tables. */
+    minGuests?: number;
+    /** Table only — the most guests the table seats. Ignore for non-tables. */
+    maxGuests?: number;
+    /** On a SEATED event, this type can still be bought directly (a quantity
+     *  dropdown) instead of going through the seat map. When false on a seated
+     *  event, the type is picked on the map — the ticket screen shows it read-only
+     *  and routes to "Select seats". Meaningless for non-seated events. */
+    allowDirectPurchase: boolean;
+    /** This sold-out type accepts waiting-list sign-ups — offer a "join the
+     *  waiting list" affordance and call `joinWaitingList` with this id. */
+    waitingListEnabled?: boolean;
+    waitingListMaxQuantity?: number;
+    /** Raw rich-text description (may contain HTML). */
+    descriptionRich: string | null;
+    /** Present for time-slot tickets: the session this id belongs to (display
+     *  metadata only — the id already encodes the session). */
+    timeSlot?: {
+        date: string;
+        time: string;
+    };
+}
+/** What the user picked on the tickets screen. */
+interface TicketSelection {
+    id: string;
+    name: string;
+    optionName: string;
+    price: number;
+    quantity: number;
+    currency: string;
+}
+/**
+ * One reserved seat resolved to a cart line — the seat-map analogue of
+ * `TicketSelection`. Built by `<SeatMap/>` from the reserved seat + the buyer's
+ * chosen ticket type (and, for table/group tiers, the guest count), then fed to
+ * `checkout.setSeats(eventId, lines)`. Mirrors the fields the legacy
+ * `seatMapContainer` used to POST a seated add-to-cart.
+ */
+interface SeatLine {
+    /** `"rowId:seatIndex"` — the reservation key that holds this seat server-side. */
+    seatId: string;
+    /** The seat's tier id (from `getTierIdBasedOnSeatId`). */
+    tierId: string;
+    /** Chosen ticket type id (`TicketTypeTierRelationsData.ticket_type_id`). */
+    ticketTypeId: string;
+    /** The type's option-matrix key (`ticket_type_option`) — the `product_options` key. */
+    optionName: string;
+    /** Unit price (`ticket_type_price`). */
+    price: number;
+    /** Guest count, present ONLY for guest-capable (table/group) types. */
+    guests?: number;
+}
+/** A waiting-list sign-up for a sold-out event or ticket type. */
+interface WaitingListEntry {
+    firstName: string;
+    lastName: string;
+    email: string;
+    /** Restrict to one sold-out ticket type (its `TicketType.id`). */
+    ticketTypeId?: string;
+    quantity?: number;
+}
+/**
+ * An event terms/conditions block the buyer may need to accept. CLIENT-SIDE
+ * gate only (nothing is sent — the server already knows the conditions): the
+ * pre-flight blocks placement until every `isRequired` block is accepted.
+ */
+interface EventCondition {
+    id: string;
+    name: string;
+    /** The condition text (may contain HTML). */
+    content: string;
+    isRequired: boolean;
+}
+interface EventAddon {
+    /** Raw numeric add-on id (string) — the key in the add-ons map. */
+    id: string;
+    name: string;
+    /** May contain HTML. */
+    description: string | null;
+    /** Price in currency units (the wire sends cents; converted here). */
+    price: number;
+    currency: string;
+    feeIncluded: boolean;
+    imageUrl: string | null;
+    /**
+     * Public reads send only a SOLD-OUT SIGNAL, never a count: `0` = sold out,
+     * `null` = available (see AddOnService::public_stock_signal). Never treat it
+     * as a quantity cap — the remaining stock is already folded into
+     * `maxQuantity` server-side.
+     */
+    stock: number | null;
+    /** Per-order cap, already min'd with available stock. null = unset. */
+    maxQuantity: number | null;
+    /** Cap the quantity to the number of tickets in the cart. */
+    flagLimitToTicketQuantity: boolean;
+    /** Per-ticket cap — the bound is `limitPerTicket × ticketQuantity`. null = unset. */
+    limitPerTicket: number | null;
+    /** A yes/no add-on: the quantity is 0 or 1, rendered as a checkbox. */
+    isCheckbox: boolean;
+    /** What the add-on attaches to — `'ticket'` or `'order'`. */
+    level: string | null;
+    /** Group heading shown on the web (e.g. "Do you need transportation?"). */
+    groupName: string | null;
+    /** Backend "required" flag: an in-stock required add-on must be selected
+     *  before placing the order (sold-out required add-ons are exempt). */
+    required: boolean;
+    /** Raw ticket-type ids this add-on applies to. Empty/null = any ticket. */
+    prerequisiteTicketTypeIds: string[] | null;
+}
+/** `{ [rawAddOnId]: quantity }` */
+type AddonSelection = Record<string, number>;
+/** A required-add-on shape the pre-flight checks (the api's `EventAddon`
+ *  satisfies this; sold-out required add-ons are exempt). */
+interface RequiredAddOnLike {
+    id: string | number;
+    name?: string;
+    required?: boolean;
+    /** null/undefined = untracked (never sold out); explicit 0 = sold out. */
+    stock?: number | null;
+    active?: boolean;
+}
+type CustomFieldType = 'text' | 'textarea' | 'phone' | 'email' | 'radio' | 'select' | 'select_multi' | 'checkbox' | 'image';
+interface CustomFieldOption {
+    id: string;
+    /** Display label. */
+    name: string;
+    /** The value the backend expects submitted. */
+    value: string;
+}
+/** One event custom field (order- or ticket-scoped). */
+interface EventCustomField {
+    id: string;
+    /** Wire key for the captured value (`data_capture[name]`). */
+    name: string;
+    label: string;
+    type: CustomFieldType;
+    required: boolean;
+    description: string | null;
+    /** Normalized default: checkbox → '1'|null; select_multi → string[]; else
+     *  string. */
+    defaultValue: string | string[] | null;
+    options: CustomFieldOption[];
+    /** Ticket-type scoping: a TICKET field applies only to holders whose
+     *  ticketTypeId is in this list. Null = all ticket types. */
+    ticketTypeIds: string[] | null;
+}
+interface EventCustomFieldGroup {
+    id: string;
+    label: string | null;
+    /** 'order' fields ride data_capture; 'ticket' fields ride each holder's
+     *  ticket_data_capture; 'add-on' fields ride add_on_data_capture keyed by
+     *  this group's id (the add-on id). */
+    scope: 'order' | 'ticket' | 'add-on';
+    fields: EventCustomField[];
+}
+/** Captured values: `{ [field.name]: value }` (string, or string[] for
+ *  select_multi). */
+type CustomFieldValues = Record<string, string | string[]>;
+/** Raw gate flags off `GET v1/checkout-configs` (next_page_info). */
+interface FieldGates {
+    show_nationality_field?: boolean;
+    nationality_field_required?: boolean;
+    show_gender_field?: boolean;
+    gender_field_required?: boolean;
+    require_instagram?: boolean;
+    /** Phone number: shown unless hidden; required when `phone_required`. */
+    phone_required?: boolean;
+    hide_phone_field?: boolean;
+    /** Date of birth / age verification. */
+    age_required?: boolean;
+    minimum_age?: number | string | null;
+    /** Free tickets skip the address block. */
+    free_ticket?: boolean;
+}
+/** Evaluated buyer-field visibility (render gated fields when shown). */
+interface BuyerFieldVisibility {
+    showNationality: boolean;
+    nationalityRequired: boolean;
+    showGender: boolean;
+    genderRequired: boolean;
+    requireInstagram: boolean;
+    /** Phone number field. */
+    showPhone: boolean;
+    phoneRequired: boolean;
+    /** Date of birth (age verification); `minimumAge` when the event sets one. */
+    showDob: boolean;
+    dobRequired: boolean;
+    minimumAge?: number;
+    /** Postal address block (street/city/state/country/zip) — paid events only. */
+    showAddress: boolean;
+}
+interface CurrencyOption {
+    code: string;
+    name: string;
+}
+interface CurrencyState {
+    currency: string;
+    symbol: string;
+    default: string;
+    available: CurrencyOption[];
+}
+interface CurrencySync {
+    state: CurrencyState;
+    /** True after an explicit switch: refetch the catalog and reset any ticket
+     *  selection (a currency change is a full reprice). */
+    requiresCatalogRefresh: boolean;
+}
+interface CurrencySyncOptions {
+    /** Replay a carried-over currency as a default: fills an empty preference,
+     *  never overwrites the buyer's own switch. */
+    seed?: boolean;
+}
+type CurrencyTransport = (eventId: string | number, code?: string, options?: CurrencySyncOptions) => Promise<CurrencyState>;
+
+/**
+ * Pricing shapes — the server-priced breakdown, Stripe config, payment-plan
+ * availability, wallet availability, and the display-ready price-breakdown rows.
+ */
+interface BreakdownLine {
+    name: string;
+    quantity: number;
+    unit: string;
+    total: number;
+    /** NUMERIC decrypted ticket-type id for this line — pass to each holder as
+     *  `CheckoutHolder.ticketTypeId`. */
+    ticketTypeId: string;
+}
+/** Server-priced cart breakdown (authoritative totals incl. fees). */
+interface CheckoutBreakdown {
+    total: number;
+    totalAddOns: number;
+    currencyCode: string;
+    currencySymbol: string;
+    tickets: BreakdownLine[];
+}
+interface StripeConfig {
+    publishableKey: string;
+    accountId: string | null;
+}
+/**
+ * Pre-order installment preview (display-only). Every field optional since
+ * older backends omit the block.
+ *
+ * This mirrors the FULL `payment_plan_configuration` the backend already sends
+ * (Checkout.php `$stripe_payment_plan_configuration`). The admin-fee and
+ * non-refundable fields are financial disclosures, not decoration — the hosted
+ * terms block states what a buyer forfeits on default, so anything that renders
+ * a plan must be able to say the same. See `paymentPlanTerms`.
+ */
+interface CheckoutPaymentPlanPreview {
+    interval?: number;
+    totalInstallments?: number;
+    pricePerInstallment?: number;
+    total?: number;
+    downPaymentEnabled?: boolean;
+    downPaymentAmount?: number | null;
+    currency?: string;
+    currencySymbol?: string;
+    customMessage?: string | null;
+    /** Brand's word for the plan ("Payment Plan", "Layaway", …). Drives copy. */
+    terminology?: string;
+    manufacturerName?: string;
+    /** Equal installments with no separate down payment — changes the wording. */
+    isAutoEqual?: boolean;
+    /** A per-installment admin fee applies. */
+    hasAdminFee?: boolean;
+    /** The per-installment admin fee amount. */
+    adminFee?: number | null;
+    /** How the non-refundable amount is expressed on default. */
+    nonRefundableType?: 'fixed' | 'percent' | null;
+    /** The percent (when `percent`) or the amount (when `fixed`). */
+    nonRefundableAmount?: number | null;
+    /** The resolved cash amount the buyer forfeits on default. */
+    totalNonRefundableAmount?: number | null;
+    /** Suppress the "and an admin fee of X for each installment" clause. */
+    hideNonRefundableAdminFeeText?: boolean;
+    /** Balance is charged on an absolute date, not "in {interval} days". */
+    isEventAnchored?: boolean;
+    /** The absolute final charge date, when event-anchored. */
+    finalChargeDate?: string | null;
+    /** Down-payment breakdown (the hosted templates' richer secondary lines). */
+    downPaymentMode?: string | null;
+    downPaymentScope?: string | null;
+    downPaymentPercent?: number | null;
+    downPaymentPerTicketAmount?: number | null;
+    downPaymentTicketCount?: number | null;
+}
+/** Payment-plan (installments) availability for a priced cart. */
+interface CheckoutPaymentPlan {
+    available: boolean;
+    /** Last 4 of the reusable saved card the plan can charge directly. */
+    savedCardLast4?: string;
+    /** The installment preview to render the plan option. */
+    configuration?: CheckoutPaymentPlanPreview;
+}
+/** Native-wallet availability from the pricing response. Combine with the
+ *  platform's own device-support check. Payment-plan mode suppresses both. */
+interface CheckoutWalletAvailability {
+    applePay: boolean;
+    googlePay: boolean;
+}
+/** Raw `stripe_wallets` block off the pricing response. */
+interface StripeWallets {
+    applePay?: boolean | string;
+    googlePay?: boolean | string;
+}
+/** Payment Element wallets option (`'auto'` shows, `'never'` hides). */
+interface WalletsOption {
+    applePay: 'auto' | 'never';
+    googlePay: 'auto' | 'never';
+}
+interface PriceBreakdownFeeRow {
+    name: string;
+    amount: string;
+}
+interface PriceBreakdownTicketRow {
+    name: string;
+    quantity: number;
+    is_table: boolean;
+    guest_count: number;
+    guests_label: string | null;
+    unit_price: string;
+    original_price: string | null;
+    line_total: string;
+    fee_label: string | null;
+    fees_rows: PriceBreakdownFeeRow[];
+    discount: string | null;
+    description: string | null;
+}
+interface PriceBreakdownAddOnRow {
+    name: string;
+    quantity: number;
+    show_price: boolean;
+    unit_price: string;
+    line_total: string;
+}
+interface PriceBreakdown {
+    currency: string;
+    tickets: PriceBreakdownTicketRow[];
+    add_ons: PriceBreakdownAddOnRow[];
+    add_ons_title: string;
+    add_on_fee_label: string | null;
+    tax: PriceBreakdownFeeRow | null;
+    insurance: string | null;
+    debt: {
+        pay_now: string;
+        at_check_in: string;
+    } | null;
+    total: string;
+}
+
+/**
+ * Payment shapes — gateway identity, per-rail request/response bodies, and the
+ * interpreted outcomes the `payment` api and `logic/payment` produce.
+ */
+/** Post-order gateway, from the review's payment_method block. */
+type Gateway = 'stripe' | 'razorpay' | 'xendit' | 'unsupported';
+/** Pre-order gateway, from the cart payment-config block. */
+type PreOrderGateway = 'stripe_payment_intents' | 'xendit' | 'razorpay';
+interface XenditProcessor {
+    key: string;
+    label: string;
+    icon?: string;
+}
+interface XenditPreOrderConfig {
+    publishableKey: string;
+    onBehalfOf: string | null;
+    processors: XenditProcessor[];
+    failureReasons: Record<string, string>;
+    ui: Record<string, string>;
+}
+interface PayPalTabConfig {
+    payment_method_id: number;
+    payment_method_hash: string;
+    title: string;
+    indication_text: string;
+}
+/** Pre-order deferred Stripe Elements config (single-page card mount). */
+interface PreOrderPaymentConfig {
+    gateway: string;
+    basic_config: {
+        apiKey: string;
+        [key: string]: unknown;
+    };
+    elements_config: Record<string, unknown>;
+    additional_config?: Record<string, unknown> | null;
+    stripe_wallets?: Record<string, unknown> | null;
+    payment_plan_available: boolean;
+    payment_plan_configuration?: Record<string, unknown> | null;
+    setup_elements_config?: Record<string, unknown> | null;
+}
+interface PaymentMethodTypeInput {
+    paymentMethodType: string;
+    orderId: number | string;
+    orderHash: string;
+    /** pi_… — the intent id, or derive it from the review's client secret. */
+    stripeIntentId: string;
+}
+interface PaymentMethodTypeRequest {
+    payment_method_type: string;
+    order_id: number;
+    order_hash: string;
+    stripe_intent_id: string;
+}
+interface RedirectConfirmRequest {
+    payment_method_id: string;
+    return_url: string;
+}
+interface RedirectConfirmResponse {
+    status: string;
+    requires_action: boolean;
+    next_action_type?: string | null;
+    redirect_url?: string | null;
+    client_secret?: string;
+}
+type RedirectOutcome = {
+    kind: 'redirect';
+    url: string;
+} | {
+    kind: 'settled';
+    status: string;
+} | {
+    kind: 'inline_action';
+    clientSecret: string;
+    nextActionType: string;
+}
+/** requires_action without a redirect URL or client secret — never treat as
+ *  settled. */
+ | {
+    kind: 'unresolved_action';
+    status: string;
+};
+interface OxxoVoucher {
+    voucherUrl: string;
+    voucherNumber: string | null;
+    /** Unix seconds when the voucher expires, when surfaced. */
+    expiresAt: number | null;
+}
+interface ChangePaymentMethodInput {
+    paymentMethodId: number;
+    paymentMethodHash: string;
+    orderId: number | string;
+    orderHash: string;
+}
+interface PayPalForm {
+    action_url: string;
+    fields: Record<string, string>;
+}
+interface SavedPlanCard {
+    last4: string;
+    paymentMethodId: string;
+}
+interface InstallmentOffer {
+    count: number;
+    interval: string;
+    type: string;
+    total?: number;
+    per_installment?: number;
+    total_formatted?: string;
+    per_installment_formatted?: string;
+    diff_from_original_formatted?: string;
+    currency?: string;
+    currency_symbol?: string;
+    [key: string]: unknown;
+}
+interface InstallmentOffers {
+    installments: InstallmentOffer[];
+    installmentsSupported: boolean;
+    original: {
+        total?: number;
+        total_formatted?: string;
+        has_table?: boolean;
+    };
+}
+interface XenditEWalletChargeInput {
+    orderId: number | string;
+    orderHash: string;
+    /** payment_processors row key: jenius_pay, ovo, dana, linkaja, gcash… */
+    paymentType: string;
+    /** Jenius Pay's $cashtag. */
+    cashtag?: string;
+    /** OVO's mobile number. */
+    phoneNumber?: string;
+}
+type XenditChargeOutcome = {
+    kind: 'redirect';
+    url: string;
+    notice: string | null;
+} | {
+    kind: 'failed';
+    reason: string;
+};
+/**
+ * A gateway-agnostic descriptor the payment UI maps back to a `PaymentRequest`.
+ * This is the UI-facing projection of the engine's request union — same rails,
+ * without the per-rail parameters the engine fills in. Keeping the two unions
+ * in one file is what makes drift between them visible.
+ */
+type PaymentMethodId = {
+    kind: 'card';
+} | {
+    kind: 'xenditCard';
+} | {
+    kind: 'applePay';
+} | {
+    kind: 'googlePay';
+} | {
+    kind: 'redirect';
+    methodType: string;
+} | {
+    kind: 'oxxo';
+} | {
+    kind: 'xenditEWallet';
+    walletKey: string;
+} | {
+    kind: 'paypal';
+} | {
+    kind: 'razorpay';
+} | {
+    kind: 'paymentPlan';
+};
+/** One selectable row in the payment-method list. */
+interface PaymentMethodOption {
+    id: PaymentMethodId;
+    /** Stable key for the list + the radio group's value. */
+    value: string;
+    label: string;
+    /** Icon URL (Xendit e-wallet rows carry one). */
+    iconUrl?: string;
+    /** The extra field this method needs before it can charge. */
+    extra?: 'cashtag' | 'phoneNumber' | null;
+}
+
+/**
+ * Order-form shapes — what the buyer fills in (billing, holders, consent) and
+ * the on-checkout request body those compose into.
+ */
+
+interface CheckoutBilling {
+    firstName: string;
+    lastName: string;
+    email: string;
+    /** UI-only confirmation value. It is never sent separately; the order API
+     *  still submits `confirm_email` from the authoritative `email` field. */
+    confirmEmail?: string;
+    phone?: string;
+    streetAddress?: string;
+    city?: string;
+    zip?: string;
+    /** Numeric backend country id (from the countries endpoint). */
+    countryId?: string;
+    /** Numeric backend state id (from the states endpoint). */
+    stateId?: string;
+    /** ISO-2 country code for payment billing_details (Stripe wants ISO, not the
+     *  backend's numeric id) — set when known; confirmers include it. */
+    countryCode?: string;
+    /** State/region code for payment billing_details — set when known. */
+    stateCode?: string;
+    /** UI/preflight hint: the selected country returned at least one state or
+     *  county option, so one must be chosen. Never sent as an order field. */
+    stateRequired?: boolean;
+    dobDay?: number;
+    dobMonth?: number;
+    dobYear?: number;
+    /** Nationality country id (from the countries endpoint's `nationality`
+     *  label). Collected when the `show_nationality_field` gate is on. */
+    nationality?: string;
+    /** 'M' | 'F'. Collected when the `show_gender_field` gate is on. */
+    gender?: string;
+    /** Bare handle or profile URL (server normalises). Collected when the
+     *  `require_instagram` gate is on. */
+    instagramHandle?: string;
+    /** ORDER-level custom field values (`data_capture`). */
+    dataCapture?: CustomFieldValues;
+}
+interface CheckoutHolder {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone?: string;
+    /** NUMERIC decrypted ticket-type id this holder's ticket belongs to (from
+     *  the pricing breakdown lines) — drives the server's ticket-type-scoped
+     *  required-field validation. */
+    ticketTypeId?: string;
+    /** TICKET-level custom field values for this holder (`ticket_data_capture`). */
+    ticketDataCapture?: CustomFieldValues;
+}
+interface CheckoutConsent {
+    ttfOptIn: boolean;
+    brandOptIn: boolean;
+}
+interface TicketHolderInput {
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    /** NUMERIC option-matrix ticket-type id (the GET v1/cart line `id`). Drives
+     *  the validator's ticket-type-scoped REQUIRED-field checks. */
+    ticketTypeId?: string | number;
+    /** Per-ticket custom fields: { [fieldName]: value } */
+    ticketDataCapture?: Record<string, unknown>;
+}
+interface BuyerFieldsInput {
+    /** Country id (each countries row carries a `nationality` label). Gate:
+     *  show_nationality_field. */
+    nationality?: string | number;
+    /** 'M' | 'F'. Gate: show_gender_field. */
+    gender?: string;
+    /** Bare handle or profile URL — the server normalises. Gate: require_instagram. */
+    instagramHandle?: string;
+}
+interface OnCheckoutInput {
+    buyerFields?: BuyerFieldsInput;
+    /** Order-level custom fields: { [fieldName]: value } */
+    dataCapture?: Record<string, unknown>;
+    ticketHolders?: TicketHolderInput[];
+    /** Add-on selections: { [addOnId]: quantity } */
+    addOns?: Record<string, number>;
+    /** Add-on custom fields: { [addOnId]: { [fieldName]: value } } */
+    addOnDataCapture?: Record<string, Record<string, unknown>>;
+}
+interface OnCheckoutAttributes {
+    nationality?: string | number;
+    gender?: string;
+    instagram_handle?: string;
+    data_capture?: Record<string, unknown>;
+    ticket_holders?: Array<Record<string, unknown>>;
+    /** Top-level per-ticket-number mirror of ticket_holders[n].ticket_data_capture. */
+    ticket_data_capture?: Array<Record<string, unknown>>;
+    add_ons?: Record<string, number>;
+    add_on_data_capture?: Record<string, Record<string, unknown>>;
+}
+type CheckoutStatus = 'idle' | 'priming' | 'ready' | 'repricing' | 'placing' | 'succeeded' | 'expired' | 'error';
+/** The outcome of `placeOrder`. */
+interface PlaceOrderResult {
+    orderHash: string;
+    free: boolean;
+    needIdVerification: boolean;
+    /** Order currency code (e.g. 'USD') — set when known. */
+    currency?: string;
+    /** The settled Stripe PaymentIntent id — card / native-wallet paths only. */
+    paymentIntentId?: string;
+    /** True when the server reported this checkout as already paid (duplicate
+     *  submission) — nothing was charged this run. */
+    alreadyPaid?: boolean;
+    /** The payment settles asynchronously (OXXO cash voucher, PayPal IPN) — show
+     *  a "payment pending" state, never a paid receipt. */
+    pending?: boolean;
+    /** OXXO: the hosted voucher URL (also emailed to the buyer). */
+    pendingVoucherUrl?: string;
+}
+/**
+ * The complete checkout state the store holds. `useCheckout()` returns this
+ * (plus the actions); a non-React app reads it via `store.getState()`.
+ */
+interface CheckoutSnapshot {
+    status: CheckoutStatus;
+    eventId?: string;
+    selections: TicketSelection[];
+    /** DECRYPTED ticket type ids for the cart — drives add-on filtering. */
+    ticketTypeIds: string[];
+    /** The event's custom-field groups (order + ticket + add-on scopes). */
+    customFields: EventCustomFieldGroup[];
+    /** Add-on custom-field VALUES, keyed by add-on id. */
+    addOnDataCapture?: Record<string, CustomFieldValues>;
+    /** Event terms/conditions (client-side gate) — placement blocks until every
+     *  required block is in `acceptedConditions`. */
+    conditions?: EventCondition[];
+    /** Which condition ids the buyer has accepted (`{ [id]: true }`). */
+    acceptedConditions?: Record<string, boolean>;
+    /** Email the buyer typed that already has an account (prompt sign-in). Null
+     *  when the last checked email has none; undefined before any check. */
+    existingAccountEmail?: string | null;
+    /** collect_names = 'yes': every holder must carry first + last name. */
+    holderNamesRequired: boolean;
+    /** Buyer-field gates (nationality/gender/Instagram) from checkout-configs. */
+    fieldGates: BuyerFieldVisibility;
+    /** Required add-ons the pre-flight blocks placement on (sold-out exempt). */
+    requiredAddOns?: RequiredAddOnLike[];
+    /** Server-priced display-ready summary (render verbatim). Null when unserved. */
+    priceBreakdown?: PriceBreakdown | null;
+    /** The event's payment gateway, identified at prime time. Drives which card
+     *  widget and method rows `<Payment/>` shows — read it synchronously instead
+     *  of re-probing. Undefined until primed (or when the backend didn't say). */
+    gateway?: PreOrderGateway;
+    /** Session currency state (multi-currency events). */
+    currency?: CurrencyState;
+    /** Authoritative totals (incl. fees). */
+    breakdown?: CheckoutBreakdown;
+    stripe?: StripeConfig;
+    /** Payment-plan (installments) availability for this cart. */
+    paymentPlan?: CheckoutPaymentPlan;
+    /** Redirect-based Stripe methods this order supports (discovery list). */
+    redirectPaymentMethods?: string[];
+    /** Native-wallet availability (Apple/Google Pay). */
+    walletAvailability?: CheckoutWalletAvailability;
+    /** Server deferred-mode Stripe Elements config (mode/amount/currency) for the
+     *  wallet-capable Payment Element mount — the old checkout's `elements_config`. */
+    stripeElementsConfig?: Record<string, unknown>;
+    addOns: AddonSelection;
+    billing?: CheckoutBilling;
+    holders: CheckoutHolder[];
+    consent: CheckoutConsent;
+    order?: PlaceOrderResult;
+    error?: string;
+    /** Epoch ms at which the cart reservation expires (absolute, background-safe). */
+    expiresAt?: number;
+}
+/**
+ * Engine options beyond the client config — the wallet/redirect settings the
+ * pay rails need. Passed to the engine at creation; separate from `TtfConfig`
+ * (which configures the transport).
+ */
+interface CheckoutOptions {
+    /** Stripe publishable key override. Usually unnecessary — the review carries
+     *  the right key + connected account per event. */
+    stripePublishableKey?: string;
+    /** Apple Pay merchant id (e.g. "merchant.com.ticketfairy.app"). */
+    merchantIdentifier?: string;
+    /** Merchant ISO country for the Apple/Google Pay sheet. Defaults to "US". */
+    merchantCountryCode?: string;
+    /** Business name on the "Pay …" line. Defaults to "Ticket Fairy". */
+    merchantName?: string;
+    /** Run Google Pay against the TEST environment (no real charge). */
+    googlePayTestEnv?: boolean;
+    /** Return URL for redirect-based Stripe methods. Defaults to the origin. */
+    redirectReturnUrl?: string;
+    /** App deep-link scheme (React Native) — redirect methods return through it. */
+    urlScheme?: string;
+}
+
+/**
+ * Account/identity shapes — existing-account lookup and the ID-verification
+ * poller contract.
+ */
+interface ContactEmailResponse {
+    error: 0 | 1;
+    message: string;
+    exists: 0 | 1 | null;
+    verified?: boolean;
+}
+interface ExistingAccount {
+    exists: boolean;
+    /** Only present when the lookup asked for verification status and the account
+     *  exists. */
+    verified: boolean | null;
+}
+/** The views every platform auth UI can render. Web uses a modal today; React
+ *  Native can map the same state/actions to screens or a native sheet later. */
+type AuthFlowView = 'login' | 'register' | 'forgot-password';
+interface AuthLoginInput {
+    email: string;
+    password: string;
+}
+/** Platform-neutral registration values. The API adapter owns the legacy
+ *  snake_case/FormData mapping; UI components should never construct it. */
+interface AuthRegistrationInput {
+    firstName: string;
+    lastName: string;
+    email: string;
+    password: string;
+    passwordConfirmation: string;
+    phone?: string;
+    streetAddress?: string;
+    city?: string;
+    zip?: string;
+    countryId?: string;
+    stateId?: string;
+    /** Advanced backend registration context (e.g. delegation access). */
+    registrationFields?: Record<string, string>;
+}
+type AuthFieldName = keyof AuthLoginInput | keyof AuthRegistrationInput;
+type AuthFieldErrors = Partial<Record<AuthFieldName, string>>;
+interface AuthValidationResult {
+    valid: boolean;
+    errors: AuthFieldErrors;
+}
+interface IdVerificationStatus {
+    required: boolean;
+    verified: boolean;
+    provider?: string | null;
+    verification_url?: string | null;
+}
+type IdVerificationPhase = 'idle' | 'polling' | 'verified' | 'timeout' | 'error';
+interface IdVerificationCallbacks {
+    fetchStatus: () => Promise<IdVerificationStatus>;
+    onPhase: (phase: IdVerificationPhase, status?: IdVerificationStatus) => void;
+    /** Injected clock — setTimeout-compatible. */
+    schedule?: (fn: () => void, ms: number) => unknown;
+}
+interface IdVerificationPoller {
+    start: () => void;
+    stop: () => void;
+}
+
+/**
+ * Shapes the checkout FORMS work in, as opposed to the wire shapes the API
+ * exchanges. A draft is what a half-filled form holds (every field present,
+ * plus display-only extras); the engine's `CheckoutBilling` / `CheckoutHolder`
+ * are what finally gets sent.
+ *
+ * These live here because web and native render different controls over the
+ * SAME form model — keeping one copy is what stops the two checkouts drifting.
+ */
+
+/** The subset of billing owned by the billing-details UI. */
+type BillingDraft = Pick<CheckoutBilling, 'firstName' | 'lastName' | 'email' | 'confirmEmail' | 'nationality' | 'gender' | 'instagramHandle' | 'phone' | 'streetAddress' | 'city' | 'zip' | 'countryId' | 'stateId' | 'countryCode' | 'stateCode'>;
+/**
+ * One attendee slot, carrying the ticket type that determines custom fields.
+ * Deliberately NOT `CheckoutHolder`: here `phone` is always present (a form
+ * field is '' rather than absent) and `ticketName` exists only to label the
+ * slot on screen.
+ */
+interface HolderDraft {
+    firstName: string;
+    lastName: string;
+    email: string;
+    phone: string;
+    ticketTypeId?: string;
+    ticketName?: string;
+    ticketDataCapture: CustomFieldValues;
+}
+/** A country or state as the pickers consume it. */
+interface LocationOption {
+    id: string | number;
+    name: string;
+    code?: string;
+}
+/** Looks up the message for a field key, or undefined when it's valid. */
+type BillingFieldError = (key: string, message?: string) => string | undefined;
+
+/**
+ * Gateway identity — which processor an event/order pays through, read the same
+ * way the hosted embed keys on it. Post-order (`detectGateway`, off the review's
+ * payment_method) and pre-order (`identifyPreOrderGateway` + the Xendit/PayPal
+ * config, off the cart payment block).
+ */
+
+/** Post-order gateway from the review's payment_method block. */
+declare const detectGateway: (paymentMethod: Record<string, unknown> | null | undefined) => Gateway;
+/** Pre-order gateway from the cart payment-config block. Null when unrecognised. */
+declare const identifyPreOrderGateway: (cartAttributes: Record<string, unknown> | null | undefined) => PreOrderGateway | null;
+/** Xendit pre-order config (publishable key, processors, UI). Null when the
+ *  event isn't Xendit or the key is missing. */
+declare const xenditPreOrderConfig: (cartAttributes: Record<string, unknown> | null | undefined) => XenditPreOrderConfig | null;
+/** PayPal Standard tab config off the cart payment block. Null when absent. */
+declare const paypalTabConfig: (cartAttributes: Record<string, unknown> | null | undefined) => PayPalTabConfig | null;
+/** Pre-order deferred Stripe Elements config (single-page card mount). Null in
+ *  every fallback case (no config, non-Stripe, free cart). */
+declare const resolvePaymentConfig: (cartAttributes: Record<string, unknown> | null | undefined) => PreOrderPaymentConfig | null;
+
+/**
+ * Pricing logic — resolve the display-ready server breakdown, build the
+ * display-only add-on query, and map `stripe_wallets` to the Payment Element
+ * wallets option (payment-plan mode forces both wallets off — they can't
+ * authorize future installments).
+ */
+
+/** Query-string form of the display-only add-on map: `add_ons[<id>]=<qty>`.
+ *  The server caps at 50 entries / qty 100 and drops anything not in the cart. */
+declare const priceBreakdownAddOnsQuery: (addOns: Record<string | number, number> | null | undefined) => string;
+/** Pull the `price_breakdown` block off cart attributes. Null when the backend
+ *  doesn't serve it (older backends) — callers keep their own rendering. */
+declare const resolvePriceBreakdown: (cartAttributes: Record<string, unknown> | null | undefined) => PriceBreakdown | null;
+declare const walletsOption: (stripeWallets: StripeWallets | null | undefined, paymentPlanMode?: boolean) => WalletsOption;
+
+/**
+ * Checkout logic — compose the on-checkout body (in-body per-ticket capture,
+ * order data_capture, buyer fields), evaluate buyer-field gates, find missing
+ * required add-ons, and detect seated events.
+ *
+ * `buildOnCheckoutBody` matters: on_checkout is the SAME engine the hosted
+ * checkout runs, and REQUIRED custom fields are validated AT PLACEMENT — events
+ * with required fields can only be placed when the capture rides this body.
+ */
+
+/** True when a custom-field answer has been provided (array = at least one). */
+declare const hasValue: (value: string | string[] | undefined) => boolean;
+/** The checkout's single email rule — UIs must not re-derive their own. */
+declare const isEmail: (value: string | undefined) => boolean;
+/** The checkout's single phone rule: 7–15 digits, punctuation ignored. */
+declare const isPhone: (value: string | undefined) => boolean;
+/**
+ * Does a ticket-scoped custom field apply to this ticket type? A field with no
+ * `ticketTypeIds` applies to every ticket. This is the single owner of the rule
+ * — the UIs previously each carried their own copy.
+ */
+declare const fieldAppliesToTicketType: (field: Pick<EventCustomField, "ticketTypeIds">, ticketTypeId?: string | number) => boolean;
+/** The ticket-scoped fields that apply to a given ticket type. */
+declare const ticketFieldsFor: <T extends Pick<EventCustomField, "ticketTypeIds">>(fields: T[], ticketTypeId?: string | number) => T[];
+/**
+ * Are every required field in `fields` answered? Mirrors the engine's own
+ * preflight, including its rule that `image` fields are server-authoritative
+ * and never block the client.
+ */
+declare const customFieldsComplete: (fields: EventCustomField[], values: CustomFieldValues) => boolean;
+interface CheckoutDetailsState {
+    billing?: CheckoutBilling;
+    holders: CheckoutHolder[];
+    selections: TicketSelection[];
+    breakdown?: CheckoutBreakdown;
+    holderNamesRequired: boolean;
+    fieldGates: BuyerFieldVisibility;
+    customFields: EventCustomFieldGroup[];
+}
+interface CheckoutDetailsValidationOptions {
+    /** Embedded guest checkout asks the buyer to type their email twice. */
+    requireEmailConfirmation?: boolean;
+    /** Always collect one named holder per selected ticket. The hosted event
+     *  checkout normally follows the backend holder-name/custom-field gates;
+     *  tf-sports' embedded flow opts into this stricter policy. */
+    collectTicketHolders?: boolean;
+    /** Storefront parity: collect email and phone for every ticket holder. */
+    requireHolderContact?: boolean;
+    /** Injectable clock keeps minimum-age checks deterministic in tests. */
+    now?: Date;
+}
+/**
+ * One source of truth for every buyer/holder field that must be completed
+ * before payment. UI sections use the returned labels for gating and the
+ * framework-agnostic engine calls the same function during preflight.
+ */
+declare const missingCheckoutDetails: (state: CheckoutDetailsState, options?: CheckoutDetailsValidationOptions) => string[];
+/** Merge the parity fields into an existing attributes `base` object. */
+declare const buildOnCheckoutBody: (input: OnCheckoutInput, base?: Record<string, unknown>) => OnCheckoutAttributes & Record<string, unknown>;
+/** Evaluate the buyer-field gates off `GET v1/checkout-configs` (next_page_info). */
+declare const evaluateFieldGates: (gates: FieldGates | null | undefined) => BuyerFieldVisibility;
+/**
+ * The required add-ons the selection is still missing. Empty means the
+ * requirement is satisfied. A sold-out required add-on (stock exactly 0) is
+ * exempt — it never blocks placement (the hosted rule).
+ */
+declare const missingRequiredAddOns: <T extends RequiredAddOnLike>(addOns: T[] | null | undefined, selectedQuantities: Record<string | number, number> | null | undefined) => T[];
+/** The hosted cap when nothing else bounds an add-on (embed-checkout-app.js). */
+declare const ADD_ON_DEFAULT_MAX_QUANTITY = 10;
+/**
+ * The selectable quantity cap for ONE add-on — the minimum of every bound that
+ * applies, mirroring the hosted `order_add_on` partial exactly:
+ *
+ *   - `flagLimitToTicketQuantity` → the number of tickets in the cart
+ *   - `limitPerTicket`            → `limitPerTicket × ticketQuantity`
+ *   - `maxQuantity`               → itself (already min'd with available stock
+ *                                   server-side on public reads)
+ *   - nothing set                 → the hosted default of 10
+ *   - `isCheckbox`                → a yes/no choice, so at most 1
+ *
+ * This is NOT cosmetic: the server hard-rejects quantities above these
+ * (`add_on_max_quantity`), so an over-generous picker builds an order that
+ * fails at placement. `stock` is deliberately not a candidate — on public
+ * reads it is only a sold-out signal (0 or null), never a count.
+ */
+declare const addOnMaxQuantity: (addOn: Pick<EventAddon, "flagLimitToTicketQuantity" | "limitPerTicket" | "maxQuantity" | "isCheckbox">, ticketQuantity: number) => number;
+/**
+ * The selectable quantity bounds for a ticket type's dropdown: `{ min, max,
+ * step }`. Tables are the subtlety — their quantity is a GUEST count (bounded by
+ * `minGuests`/`maxGuests`), not a count of tickets, so a "full table of 8" must
+ * offer 8…maxGuests and never a smaller number; the generic `min/maxQuantity`
+ * stay 1/10 on the wire and would wrongly let the buyer pick fewer. `step` is the
+ * `multiplier` (the cart sells in blocks of N). Mirrors the old checkout's
+ * `getTicketSelectOptions(maxCount, minCount, multiplier)` with
+ * `maxCount = isTable ? maxGuests : maxQuantity`.
+ */
+declare const ticketQuantityRange: (ticket: Pick<TicketType, "isTable" | "minQuantity" | "maxQuantity" | "minGuests" | "maxGuests" | "multiplier">) => {
+    min: number;
+    max: number;
+    step: number;
+};
+/**
+ * Reserved-seating detection. A seated event sells through a seat-map picker, so
+ * a surface without one hands the buyer off to the event page. Accepts event
+ * details, the cart/payment payload, or raw event attributes.
+ */
+declare const isSeatedEvent: (event: object | null | undefined) => boolean;
+
+declare const interpretRedirectConfirm: (response: RedirectConfirmResponse) => RedirectOutcome;
+/** Read the voucher off a confirmed PaymentIntent's next action — tolerant of
+ *  both the web (oxxo_display_details) and RN (voucherURL) shapes. */
+declare const oxxoVoucherFromNextAction: (nextAction: Record<string, unknown> | null | undefined) => OxxoVoucher | null;
+declare const buildChangePaymentMethodAttributes: (input: ChangePaymentMethodInput) => Record<string, unknown>;
+declare const resolvePayPalForm: (attributes: Record<string, unknown> | null | undefined) => PayPalForm | null;
+/** The saved-card shortcut off the review's payment_method — null unless the
+ *  plan configuration carries a reusable card. */
+declare const savedPlanCard: (paymentMethod: Record<string, unknown> | null | undefined) => SavedPlanCard | null;
+declare const requiresFeeReprice: (type: string | null | undefined) => boolean;
+declare const buildPaymentMethodTypeAttributes: (input: PaymentMethodTypeInput) => PaymentMethodTypeRequest;
+/** A PaymentIntent client secret is `pi_<id>_secret_<nonce>` — the review
+ *  carries the secret, the re-price endpoint wants the id. Null for setup-intent
+ *  secrets (seti_…) and anything else. */
+declare const paymentIntentIdFromClientSecret: (clientSecret: string | null | undefined) => string | null;
+declare const buildInstallmentOffersFields: (input: {
+    paymentIntentId: string;
+    paymentMethodId: string;
+}) => Record<string, string>;
+declare const resolveInstallmentOffers: (raw: Record<string, unknown> | null | undefined) => InstallmentOffers;
+declare const buildConfirmInstallmentsFields: (input: {
+    paymentIntentId: string;
+    offer: InstallmentOffer;
+}) => Record<string, string>;
+declare const confirmInstallmentsHasNextAction: (raw: Record<string, unknown> | null | undefined) => boolean;
+/** The flat form-field map (PHP bracket notation) the charge endpoint reads —
+ *  send it form-encoded, never as JSON. */
+declare const buildXenditEWalletChargeFields: (input: XenditEWalletChargeInput) => Record<string, string>;
+declare const interpretXenditChargeResponse: (raw: Record<string, unknown> | null | undefined) => XenditChargeOutcome;
+
+/**
+ * Payment-plan terms — the buyer-facing disclosure block.
+ *
+ * A faithful port of the hosted checkout's `renderPaymentPlanSelector`
+ * (embed-checkout-app.js), which composes these paragraphs from the same
+ * `payment_plan_configuration` the backend already sends us. Everything here is
+ * pure string composition over the preview DTO, so web and native render the
+ * identical wording and one set of tests covers both.
+ *
+ * This is not cosmetic copy. The admin-fee line states a real per-installment
+ * charge, and the non-refundable line states what the buyer forfeits if they
+ * default. A plan UI that omits them is understating the cost of the purchase.
+ *
+ * Wording is the hosted DEFAULT for each i18n key. Consumers that already
+ * localize can map over the returned parts by `id`.
+ */
+
+/** The default word for a plan when the brand hasn't renamed it. */
+declare const DEFAULT_PLAN_TERMINOLOGY = "Payment Plan";
+/** The brand's word for the plan — "Payment Plan", "Layaway", … */
+declare const planTerminology: (plan?: CheckoutPaymentPlanPreview | null) => string;
+/** `currency_symbol` + 2dp, matching the hosted `money()` helper exactly. */
+declare const formatPlanMoney: (plan: CheckoutPaymentPlanPreview | null | undefined, value: number | null | undefined) => string;
+/** "Click to pay in 3 payments with a Payment Plan" — the opt-in label. */
+declare const planCheckboxLabel: (plan: CheckoutPaymentPlanPreview) => string;
+/** The plan's submit CTA — "Confirm Payment Plan". */
+declare const planConfirmLabel: (plan?: CheckoutPaymentPlanPreview | null) => string;
+/** "CN Brand TTF Payment Plan Terms" — the terms heading. */
+declare const planTermsTitle: (plan: CheckoutPaymentPlanPreview) => string;
+/** One paragraph of the terms block. `id` is stable for localization/testing. */
+interface PlanTermsParagraph {
+    id: 'schedule' | 'adminFee' | 'nonRefundable' | 'custom' | 'note';
+    text: string;
+}
+/**
+ * The full terms block, in render order. Empty when there is nothing to state
+ * (no installment shape), so callers can render unconditionally.
+ */
+declare const paymentPlanTerms: (plan: CheckoutPaymentPlanPreview | null | undefined) => PlanTermsParagraph[];
+
+/**
+ * Account/session logic — interpret the existing-account lookup and drive the
+ * multi-currency preference sync.
+ */
+
+/** Normalize the `/ajax/contact-email` response to a boolean existence flag. */
+declare const interpretContactEmail: (raw: Partial<ContactEmailResponse> | null | undefined) => ExistingAccount;
+/** True when the event offers more than one currency (render a switcher only
+ *  then — currency selection exists solely for multi-currency events). */
+declare const isMultiCurrency: (state: CurrencyState | null | undefined) => boolean;
+/**
+ * Run a currency sync through the injected transport. A bare sync (no code)
+ * geo-seeds and reports state; a code switches it (requiresCatalogRefresh — a
+ * currency change is a full reprice, so refetch the catalog and reset selection).
+ */
+declare const syncCurrency: (transport: CurrencyTransport, eventId: string | number, code?: string, options?: CurrencySyncOptions) => Promise<CurrencySync>;
+
+/**
+ * Authentication rules shared by web and React Native. This module is pure:
+ * no React, browser APIs, FormData, or transport. Platform UI owns only field
+ * rendering while the API layer owns the final multipart encoding.
+ */
+
+declare const normalizeAuthEmail: (email: string) => string;
+declare const validateLoginInput: (input: AuthLoginInput) => AuthValidationResult;
+declare const validatePasswordResetEmail: (email: string) => AuthValidationResult;
+declare const validateRegistrationInput: (input: AuthRegistrationInput, options?: {
+    requireAddress?: boolean;
+    requireState?: boolean;
+}) => AuthValidationResult;
+/** Map the platform-neutral shape to the backend's registration contract. */
+declare const buildRegistrationFields: (input: AuthRegistrationInput) => Record<string, string>;
+
+/**
+ * ID-verification poller — a NEED_ID_VERIFICATION order signals
+ * `needIdVerification`; the buyer completes the provider check in a new
+ * tab/window while this polls `GET v1/order/:hash/id-verification` until
+ * verified. Pure state machine — fetch and clock are injected, so it runs
+ * identically in React, React Native, and tests (5s ticks, capped).
+ */
+
+declare const ID_VERIFICATION_POLL_MS = 5000;
+declare const ID_VERIFICATION_MAX_TICKS = 60;
+declare const ID_VERIFICATION_MAX_CONSECUTIVE_FAILURES = 3;
+declare const createIdVerificationPoller: (callbacks: IdVerificationCallbacks) => IdVerificationPoller;
+
+/**
+ * The checkout store — a tiny framework-agnostic observable over the
+ * `CheckoutSnapshot`. The engine writes to it; `useCheckout()` (or a plain
+ * `subscribe()` in a non-React app) reads from it. No React, no globals: the
+ * same store instance drives web, React Native, Node, and tests.
+ *
+ * State updates are immutable (a new snapshot object each change) so
+ * `useSyncExternalStore` and shallow-equality consumers re-render correctly.
+ *
+ * `progress` is separate on purpose: it holds the retry-safety bookkeeping
+ * (which order exists, whether it's been charged) that must NEVER be part of
+ * the reactive snapshot — it's how retries avoid creating a second order or
+ * charging twice.
+ */
+
+type CheckoutListener = (snapshot: CheckoutSnapshot) => void;
+/** Retry-safety bookkeeping — mutated directly by the engine, never rendered. */
+interface OrderProgress {
+    /** The created order's hash — a retry reuses it instead of minting a second. */
+    orderHash?: string;
+    /** True once the charge landed — a retry then only replays finalization. */
+    paymentConfirmed?: boolean;
+}
+interface CheckoutStore {
+    /** The current snapshot (stable reference until the next change). */
+    getState: () => CheckoutSnapshot;
+    /** Merge a partial snapshot (or a function of the current one) and notify. */
+    setState: (patch: Partial<CheckoutSnapshot> | ((prev: CheckoutSnapshot) => Partial<CheckoutSnapshot>)) => void;
+    /** Subscribe to changes; returns an unsubscribe function. */
+    subscribe: (listener: CheckoutListener) => () => void;
+    /** Reset to the initial idle snapshot (and clear progress) and notify. */
+    reset: () => void;
+    /** Retry-safety state (order hash + charged flag). Not reactive. */
+    progress: OrderProgress;
+    /** Drop any half-created order — the cart contents changed, so a previously
+     *  created order is stale and must not be reused. */
+    invalidateOrderProgress: () => void;
+    /** Move to the terminal 'expired' state and clear progress. */
+    expireCart: () => void;
+}
+/** The empty checkout — what every store starts at and `reset()` returns to. */
+declare const initialSnapshot: () => CheckoutSnapshot;
+declare const createCheckoutStore: (initial?: CheckoutSnapshot) => CheckoutStore;
+
+/**
+ * The payment-confirmation port — the hexagonal seam that keeps the engine
+ * framework- AND payment-SDK-agnostic. The orchestration is pure TS EXCEPT for
+ * the calls that talk to a Stripe SDK (init, read intent status, confirm card /
+ * wallet). Those live behind this interface: React Native binds it with
+ * @stripe/stripe-react-native, web with stripe-js, tests with a fake.
+ *
+ * Status vocabulary: confirmers return Stripe PaymentIntent statuses in the RN
+ * SDK's PascalCase form ('Succeeded' | 'RequiresCapture' | 'Processing' | …).
+ * Adapters over SDKs with other spellings (stripe-js is lowercase) normalize.
+ */
+
+interface PaymentConfirmer {
+    /** Initialize the underlying SDK for the given keys. */
+    init(options: {
+        publishableKey: string;
+        /** Stripe connected-account id (already cleaned — never ''). */
+        accountId?: string;
+        /** Apple Pay merchant id, when the platform supports it. */
+        merchantIdentifier?: string;
+        /** App deep-link scheme (React Native) — redirect methods return through it. */
+        urlScheme?: string;
+    }): Promise<void>;
+    /** Status of the PaymentIntent behind `clientSecret`, or undefined when it
+     *  can't be retrieved. Used to skip re-charging on retries. */
+    getIntentStatus(clientSecret: string): Promise<string | undefined>;
+    /** Confirm a card payment. Returns the resulting intent status or throws. */
+    confirmCard(clientSecret: string, billing: CheckoutBilling): Promise<string | undefined>;
+    /** Present the platform-pay sheet (Apple Pay on iOS). Returns the resulting
+     *  intent status or throws — a user-cancelled sheet is an error. */
+    confirmApplePay(clientSecret: string, total: string, currencyCode: string, merchant: {
+        merchantCountryCode?: string;
+        merchantName?: string;
+    }): Promise<string | undefined>;
+    /** Present the Google Pay sheet (Android). Optional — only platforms with a
+     *  native Google Pay SDK bind it; unbound, the engine throws UNSUPPORTED_GATEWAY. */
+    confirmGooglePay?(clientSecret: string, total: string, currencyCode: string, merchant: {
+        merchantCountryCode?: string;
+        merchantName?: string;
+        /** Use Google Pay's TEST environment (no real charge). */
+        testEnv?: boolean;
+    }): Promise<string | undefined>;
+}
+/**
+ * A payment is confirmed enough to finalize in any of these states: Succeeded
+ * (auto-capture), RequiresCapture (manual-capture authorizes now, captures
+ * later — NOT a failure), or Processing (settling asynchronously).
+ */
+declare const CONFIRMED_INTENT_STATUSES: string[];
+/**
+ * A Stripe connected-account id, or undefined when there is none. The backend
+ * returns '' for platform-account events; passing '' sets an empty
+ * `Stripe-Account` header, which Stripe rejects — coerce empties to undefined.
+ */
+declare const cleanAccountId: (id?: string | null) => string | undefined;
+/**
+ * Optional confirmer capabilities the alternative rails need. A platform that
+ * doesn't implement one simply can't run that rail — the engine throws a typed
+ * UNSUPPORTED_GATEWAY error instead of failing mid-payment.
+ */
+interface PaymentConfirmerExtras {
+    /** Create a card PaymentMethod (MSI offer lookup runs between creation and
+     *  the confirm). Returns the PaymentMethod id. */
+    createCardPaymentMethod?(billing: CheckoutBilling): Promise<string>;
+    /** Create a redirect-method PaymentMethod (Klarna/Afterpay/iDEAL-class).
+     *  Returns the id, or null when the platform can't express the type. */
+    createRedirectPaymentMethod?(methodType: string, billing: CheckoutBilling): Promise<string | null>;
+    /** Run the pending next action of a SERVER-confirmed intent (MSI). Throws on
+     *  failure; never confirms a second time. */
+    handleNextAction?(clientSecret: string): Promise<void>;
+    /** Confirm an OXXO voucher intent. Returns the raw nextAction payload (engine
+     *  extracts the voucher) plus any error — Stripe can report an error while
+     *  still issuing the voucher. */
+    confirmOxxo?(clientSecret: string, billing: CheckoutBilling): Promise<{
+        error?: string;
+        nextAction?: unknown;
+    }>;
+    /** Payment plan (new card): confirm the review's SetupIntent to SAVE the card
+     *  — NOTHING is charged; the plan schedules server-side. Returns the saved
+     *  PaymentMethod id, or throws. */
+    confirmPaymentPlanSetup?(clientSecret: string, billing: CheckoutBilling): Promise<string>;
+    /** Payment plan (saved-card shortcut): confirm an on-session card payment
+     *  against an EXISTING PaymentMethod — the 3DS step runs only when the plan
+     *  charge comes back requires_action. Throws on failure. */
+    confirmSavedCardPayment?(clientSecret: string, paymentMethodId: string): Promise<void>;
+}
+/** What a provider page run should load: a URL, or an inline HTML document
+ *  (PayPal's auto-submitting top-level form). */
+interface ProviderPageRequest {
+    uri?: string;
+    html?: string;
+    /** Base URL for an inline document (relative return-leg resolution). */
+    baseUrl?: string;
+    /** Navigating to a URL with this prefix ends the run as 'success'. */
+    returnUrlPrefix: string;
+}
+interface ProviderPageOutcome {
+    event: 'success' | 'dismiss' | 'failed';
+    /** The intercepted return URL (carries e.g. `redirect_status`). */
+    returnUrl?: string;
+    /** Payload posted by data-driven sheets (Razorpay's `razorpay_payment_id`,
+     *  Xendit card tokenization's `token`) — the platform's plumbing delivers it. */
+    data?: Record<string, unknown>;
+    description?: string;
+}
+/**
+ * The full port set the pay rails run on. `confirmer` is required (card/Apple
+ * Pay); the rest are optional platform capabilities:
+ * - providerPage: run a provider's page and resolve on the return leg (a
+ *   WebView sheet on RN, a redirect/popup on web).
+ * - openUrl: open an external URL (OXXO voucher, ID-verification).
+ * - onInstallmentOffers: offer MSI plans; resolve the chosen one, or null to
+ *   decline and fall through to a normal single charge.
+ * - tokenizeXenditCard: tokenize a Xendit card inline (web); when absent the
+ *   engine runs the Xendit card document through `providerPage`.
+ */
+interface CheckoutPorts extends PaymentConfirmerExtras {
+    confirmer: PaymentConfirmer;
+    providerPage?: (request: ProviderPageRequest) => Promise<ProviderPageOutcome>;
+    openUrl?: (url: string) => void | Promise<void>;
+    onInstallmentOffers?: (offers: InstallmentOffer[]) => Promise<InstallmentOffer | null>;
+    tokenizeXenditCard?: (params: {
+        publishableKey: string;
+        amount: string | number;
+        billing: CheckoutBilling;
+        onBehalfOf?: string | null;
+    }) => Promise<Record<string, unknown>>;
+}
+/** A typed "this platform can't run this rail" error — consumers branch on
+ *  `code` to hand off to the event page. */
+declare const unsupportedGatewayError: (message?: string) => Error & {
+    code: string;
+};
+/**
+ * PayPal Standard runs as a TOP-LEVEL form POST (PayPal refuses framing) — an
+ * auto-submitting form document is all the provider page needs to load.
+ */
+declare const buildAutoSubmitFormHtml: (form: PayPalForm) => string;
+
+/**
+ * Gateway sheet documents (Razorpay web checkout, Xendit card tokenization) —
+ * pure HTML string builders the `providerPage` port loads (a WebView on RN, a
+ * popup on web). No runtime deps: these just build a document; the raw card
+ * details never leave the page — only the resulting token/payment id is posted
+ * back through the provider-page outcome.
+ */
+interface RazorpayCheckoutHtmlOptions {
+    keyId: string;
+    /** Charge amount in minor units (paise) — the server's pay_now × 100. */
+    amountMinor: number;
+    description?: string;
+    buyerName?: string;
+    buyerEmail?: string;
+    orderHash: string;
+}
+/**
+ * Razorpay hosted checkout inside a WebView. Reports back via
+ * `window.ReactNativeWebView.postMessage` with `{event:'success',
+ * razorpay_payment_id}` / `{event:'dismiss'}` / `{event:'failed', description}`.
+ * `notes.order_hash` ties the charge to the order server-side.
+ */
+declare const buildRazorpayCheckoutHtml: (options: RazorpayCheckoutHtmlOptions) => string;
+interface XenditCheckoutHtmlOptions {
+    publishableKey: string;
+    /** Tokenization amount — the server-returned pay-now figure verbatim. The
+     *  CHARGE amount stays server-side in submit-payment. */
+    amount: number | string;
+    buyerFirstName?: string;
+    buyerLastName?: string;
+    buyerEmail?: string;
+    buyerPhone?: string;
+    onBehalfOf?: string | null;
+}
+/**
+ * Xendit card tokenization inside a WebView: card entry, `Xendit.card.createToken`
+ * with 3DS (the challenge iframe re-invokes the handler when it resolves),
+ * reporting `{event:'success', token}` / `{event:'failed', description}`.
+ */
+declare const buildXenditCheckoutHtml: (options: XenditCheckoutHtmlOptions) => string;
+
+/** The friendliest message for a failed call (the backend's own, else generic). */
+declare const errorMessage: (error: unknown) => string;
+/**
+ * True when a failed request is the backend rejecting an expired cart/checkout
+ * session (422 + an "…expired" message). Lets the flow show a "restart"
+ * recovery instead of a raw error; ordinary 422 validation errors stay generic.
+ */
+declare const isCartExpiredError: (error: unknown) => boolean;
+
+/** How the shopper pays. Apple/Google Pay show the native wallet sheet; card
+ *  confirms the card field the consumer rendered. */
+type PaymentMethod = 'card' | 'applePay' | 'googlePay';
+/** A full payment request — the alternative rails carry parameters. The plain
+ *  `PaymentMethod` strings remain valid ('card' ≡ `{ method: 'card' }`). */
+type PaymentRequest = {
+    method: 'card';
+}
+/** Pay with the ORDER'S OWN gateway (the prebuilt "just pay" button):
+ *  razorpay → the Razorpay sheet, xendit → the Xendit card rail,
+ *  stripe/unknown → the card path (incl. MSI). */
+ | {
+    method: 'auto';
+    description?: string;
+} | {
+    method: 'applePay';
+} | {
+    method: 'googlePay';
+}
+/** Redirect-based Stripe methods (Klarna/Afterpay/Affirm/iDEAL-class). Needs
+ *  ports.providerPage + ports.createRedirectPaymentMethod. */
+ | {
+    method: 'redirect';
+    methodType: string;
+}
+/** OXXO cash voucher (Mexico). Needs ports.confirmOxxo; result is
+ *  `pending: true` + `pendingVoucherUrl`. */
+ | {
+    method: 'oxxo';
+}
+/** Xendit e-wallet (walletKey from the pre-order processors, e.g. 'dana';
+ *  Jenius Pay wants extra.cashtag, OVO extra.phoneNumber). Needs providerPage. */
+ | {
+    method: 'xenditEWallet';
+    walletKey: string;
+    extra?: {
+        cashtag?: string;
+        phoneNumber?: string;
+    };
+}
+/** PayPal Standard (top-level form; settles via IPN — may return pending). */
+ | {
+    method: 'paypal';
+}
+/** Razorpay web checkout (posts razorpay_payment_id → settle token on /success). */
+ | {
+    method: 'razorpay';
+    description?: string;
+}
+/** Xendit CARD: the sheet tokenizes (3DS) and posts `token`; charge server-side. */
+ | {
+    method: 'xenditCard';
+}
+/** Payment plan (installments, Stripe): the card is SAVED via the review's
+ *  SetupIntent (nothing charged now), the plan schedules server-side; a
+ *  reusable saved card is charged directly (opt out with useSavedCard:false). */
+ | {
+    method: 'paymentPlan';
+    useSavedCard?: boolean;
+};
+/** The platform capabilities + wallet/redirect options the rails run on. */
+interface EngineContext {
+    ports: CheckoutPorts;
+    options: CheckoutOptions;
+}
+/** Builds the server cart for a ticket selection and prices it. Idempotent per
+ *  selection (the server replaces the cart; the store resets for the new run). */
+declare const primeWith: (store: CheckoutStore, ctx: EngineContext, eventId: string, selections: TicketSelection[]) => Promise<void>;
+/** Builds the server cart for RESERVED SEATS and prices it — the seat-map
+ *  analogue of `primeWith`. Reservations were already placed on seat click
+ *  (`ttf.seatmap.reserve`); this turns them into cart lines + prices the order,
+ *  reusing the exact same session-prime / gateway-guard / pricing pipeline. */
+declare const primeSeatsWith: (store: CheckoutStore, ctx: EngineContext, eventId: string, lines: SeatLine[]) => Promise<void>;
+/**
+ * Attach the engine to a cart that another supported flow already created
+ * (currently resale and compatibility links). Unlike `prime`, this does not
+ * add or replace ticket lines.
+ */
+declare const resumeCartWith: (store: CheckoutStore, ctx: EngineContext, eventId: string, options?: {
+    isFromResale?: boolean;
+}) => Promise<void>;
+/** Stores the add-on selection and re-prices the cart with it. */
+declare const repriceWith: (store: CheckoutStore, addOns: AddonSelection) => Promise<void>;
+declare const placeOrderWith: (store: CheckoutStore, ctx: EngineContext, method?: PaymentMethod | PaymentRequest) => Promise<PlaceOrderResult>;
+interface OrderPaymentSession {
+    /** The order to pay (from your own on-checkout call). */
+    orderHash: string;
+    /** Buyer details for the payment legs (billing_details, wallet sheets…). */
+    billing: CheckoutBilling;
+    /** Engine progress store — created on first payOrder call. Carry the session
+     *  object so a retry after a CONFIRMED charge only replays finalization. */
+    store?: CheckoutStore;
+}
+/** Pays an ALREADY-CREATED order through the engine's rails — same duplicate-
+ *  charge guards, same rails, same UNSUPPORTED_GATEWAY. Order creation and its
+ *  pre-flights are the caller's; the engine seeds a session store with the hash. */
+declare const payOrderWith: (ctx: EngineContext, session: OrderPaymentSession, method?: PaymentMethod | PaymentRequest) => Promise<PlaceOrderResult>;
+/** Syncs the session currency. A bare call geo-seeds; a `code` switches it —
+ *  after which the catalog reprices, so the engine resets the checkout (billing/
+ *  holders preserved) and the consumer re-runs prime with re-fetched tickets. */
+declare const syncCurrencyWith: (store: CheckoutStore, eventId: string, code?: string, options?: CurrencySyncOptions) => Promise<CurrencySync>;
+interface RunIdVerificationOptions {
+    /** Opens the provider verification URL. Omit to leave opening to the consumer. */
+    openUrl?: (url: string) => void | Promise<void>;
+    /** Called once the check is confirmed required. Return true to TAKE OVER (the
+     *  engine stops — no open, no poll). */
+    onRequired?: (info: {
+        orderHash: string;
+        verificationUrl: string | null;
+    }) => boolean | void;
+    onPhase?: IdVerificationCallbacks['onPhase'];
+    schedule?: IdVerificationCallbacks['schedule'];
+    /** Fires `recheck` when the provider hand-off might have completed (e.g. the
+     *  app returns to the foreground). Return an unsubscribe. */
+    registerForegroundListener?: (recheck: () => void) => () => void;
+}
+/** Standalone poller for a NEED_ID_VERIFICATION order (mint + open the URL
+ *  first via `getIdVerificationStatus(hash, true)`, then start this). */
+declare const createIdVerificationPollerFor: (orderHash: string, onPhase: IdVerificationCallbacks["onPhase"], schedule?: IdVerificationCallbacks["schedule"]) => IdVerificationPoller;
+/**
+ * Runs ID verification end-to-end for a NEED_ID_VERIFICATION order: mint the
+ * provider URL, open it, poll to completion. Already-verified → resolves now;
+ * `onRequired` returns true → resolves undefined (consumer took over); verified
+ * → resolves the status; timeout/error → REJECTS with a reassuring message (the
+ * payment already settled — treat a rejection as a verification stall, never a
+ * payment failure).
+ */
+declare const runIdVerificationWith: (orderHash: string, options?: RunIdVerificationOptions) => Promise<IdVerificationStatus | undefined>;
+interface EngineConfig {
+    /** Platform capabilities — confirmer (required) + optional rails. */
+    ports: CheckoutPorts;
+    /** Wallet/redirect options (merchant identity, redirect URL, url scheme). */
+    options?: CheckoutOptions;
+    /** Reuse an existing store; one is created otherwise. */
+    store?: CheckoutStore;
+}
+interface CheckoutEngine {
+    /** The underlying store — subscribe/getState for non-React consumers. */
+    store: CheckoutStore;
+    getSnapshot: () => CheckoutSnapshot;
+    subscribe: (listener: (s: CheckoutSnapshot) => void) => () => void;
+    /** Build + price the cart for a ticket selection. */
+    prime: (eventId: string, selections: TicketSelection[]) => Promise<void>;
+    /** Build + price the cart for reserved SEATS (seat-map events). */
+    primeSeats: (eventId: string, lines: SeatLine[]) => Promise<void>;
+    /** Resume an existing server-side cart without replacing its ticket lines. */
+    resumeCart: (eventId: string, options?: {
+        isFromResale?: boolean;
+    }) => Promise<void>;
+    /** Set the add-on selection and re-price. */
+    setAddons: (addOns: AddonSelection) => Promise<void>;
+    setBilling: (billing: CheckoutBilling) => void;
+    setHolders: (holders: CheckoutHolder[]) => void;
+    setConsent: (consent: CheckoutConsent) => void;
+    setAcceptedConditions: (accepted: Record<string, boolean>) => void;
+    setAddonDataCapture: (capture: Record<string, CustomFieldValues>) => void;
+    /** Debounced existing-account check; sets `existingAccountEmail` on the snapshot. */
+    checkBuyerEmail: (email: string) => Promise<void>;
+    /** Create the order and pay (or register free). */
+    placeOrder: (method?: PaymentMethod | PaymentRequest) => Promise<PlaceOrderResult>;
+    /** Switch/seed the session currency. */
+    syncCurrency: (eventId: string, code?: string, options?: CurrencySyncOptions) => Promise<CurrencySync>;
+    /** Run ID verification for a NEED_ID_VERIFICATION order. */
+    runIdVerification: (orderHash: string, options?: RunIdVerificationOptions) => Promise<IdVerificationStatus | undefined>;
+    reset: () => void;
+}
+/**
+ * Binds the orchestration to a store + a platform's ports. In React, wrap this
+ * with `useCheckout()`; in any other JS runtime, use it directly.
+ */
+declare const createEngine: (config: EngineConfig) => CheckoutEngine;
+
+/**
+ * Adds ALL selected ticket types to the server cart in ONE call. The endpoint
+ * REPLACES the entire cart every call, so per-type calls would keep only the
+ * last. The `{ data: { attributes } }` envelope is mandatory (the backend
+ * copies data.attributes into $_POST and 422s without it).
+ */
+declare const addTicketsToCart: (eventId: string, selections: TicketSelection[]) => Promise<{
+    holderNamesRequired: boolean;
+}>;
+/**
+ * Adds RESERVED SEATS to the server cart — the seat-map analogue of
+ * `addTicketsToCart`, a faithful port of the legacy `getAddToCartRequestData`
+ * (`seatMapContainer/utils.ts`). Kept separate because a seated order's body
+ * differs from a plain-ticket one in two ways `addTicketsToCart` can't express:
+ *
+ *  - `product_cart_quantity` is the TOTAL number of reserved seats (not the
+ *    first line's quantity), and
+ *  - when ANY line carries a guest count (tables / group tickets) the
+ *    `ticket_types` map is keyed by INDEX with `quantity = guests` (one line per
+ *    seat); otherwise it's keyed by ticket-type id with quantities aggregated.
+ *
+ * Seat ids never appear in the body — the server binds cart lines to seats
+ * through the live reservation (held by `ttf.seatmap.reserve`).
+ */
+declare const addSeatsToCart: (eventId: string, lines: SeatLine[]) => Promise<{
+    holderNamesRequired: boolean;
+}>;
+/**
+ * Reads the cart back. MANDATORY between add-to-cart and updateCheckout: this
+ * call writes the event's payment method into the PHP session, which
+ * POST v1/checkout reads. Returns reservation seconds remaining plus the raw
+ * pre-order gateway string (preserved verbatim so an unknown/future gateway
+ * stays fail-closed at the engine's Stripe-only guard).
+ */
+declare const getCart: () => Promise<{
+    expiresInSeconds: number;
+    preOrderGateway: string | null;
+}>;
+/**
+ * Checkout gates for the CURRENT cart session (`GET v1/checkout-configs`).
+ * Session-scoped: call only after the cart exists. The reliable source for the
+ * collect_names gate (staging's add-to-cart returns empty attributes).
+ */
+declare const getCheckoutConfigs: () => Promise<{
+    holderNamesRequired: boolean;
+    fieldGates: BuyerFieldVisibility;
+}>;
+interface CheckoutPricing {
+    /** DECRYPTED ticket type ids (the tickets endpoint only has encrypted ones). */
+    ticketTypeIds: string[];
+    breakdown?: CheckoutBreakdown;
+    stripe?: StripeConfig;
+    paymentPlan?: CheckoutPaymentPlan;
+    redirectPaymentMethods?: string[];
+    walletAvailability?: CheckoutWalletAvailability;
+    /** Server deferred-mode Stripe Elements config (mode/amount/currency) — mounts
+     *  the wallet-capable Payment Element exactly as the old checkout did. */
+    stripeElementsConfig?: Record<string, unknown>;
+}
+/**
+ * Prices the cart (+ chosen add-ons); returns the decrypted ticket type ids and
+ * the Stripe config. Re-run whenever the add-on selection changes.
+ *
+ * paymentOption MUST be 'single_charge' — any other value makes the backend
+ * reprice with a method-specific fee structure and silently drop booking fees
+ * (undercharge vs. the price shown on the event page).
+ */
+declare const updateCheckout: (eventId: string, addOns: AddonSelection, options?: {
+    isFromResale?: boolean;
+}) => Promise<CheckoutPricing>;
+/**
+ * Server-priced order summary (display-ready, server-formatted strings — render
+ * verbatim, never recompute). Null when the backend doesn't serve the block.
+ */
+declare const getPriceBreakdown: (addOns?: AddonSelection) => Promise<PriceBreakdown | null>;
+/** Raw pre-order payment-config attributes (GET v1/cart?payment_config=1) — feed
+ *  to core's paypalTabConfig / xenditPreOrderConfig / walletsOption. */
+declare const getPaymentConfigAttributes: () => Promise<Record<string, unknown>>;
+interface PreOrderPaymentMethods {
+    gateway: PreOrderGateway | null;
+    xenditEWallets: XenditProcessor[];
+    xenditCard: boolean;
+    paypal: boolean;
+}
+/**
+ * What this event's checkout can pay with BEFORE the order exists — read from
+ * the pre-order payment config exactly as the hosted selector does.
+ */
+declare const getPreOrderPaymentMethods: () => Promise<PreOrderPaymentMethods>;
+/**
+ * Existing-account detection (the hosted `init_email_check`): reports whether a
+ * live account owns the email so returning buyers get a sign-in prompt. Never a
+ * gate — debounce it, keep typing unblocked. Origin-rooted and form-encoded.
+ */
+declare const checkBuyerEmail: (email: string) => Promise<ExistingAccount>;
+
+/**
+ * Attribute the buyer's session to a referrer/promoter (the numeric customer id
+ * from a share/tracking link). The server credits it when the order completes;
+ * pass `null` to clear. The endpoint always answers success, so ids can't be
+ * probed.
+ */
+declare const attributeReferrer: (eventId: string, referrer: string | number | null) => Promise<void>;
+/** Join the waiting list for a sold-out event (or one sold-out ticket type). */
+declare const joinWaitingList: (eventId: string, entry: WaitingListEntry) => Promise<void>;
+/** Submit RSVP details for an RSVP-style event. */
+declare const sendRsvp: (eventId: string, data: Record<string, unknown>) => Promise<unknown>;
+/** Validate a phone number (Twilio-backed) before letting the buyer proceed. */
+declare const validatePhone: (phone: string) => Promise<{
+    valid: boolean;
+    [key: string]: unknown;
+}>;
+
+/** Purchasable ticket types for an event. */
+declare const getEventTickets: (eventId: string) => Promise<TicketType[]>;
+interface EventSeatingInfo {
+    /** The event uses reserved seating — the buyer picks on a seat map instead of
+     *  choosing quantities. Render seat-map ticket types read-only and route to
+     *  "Select seats". */
+    isSeatedEvent: boolean;
+    /** The seat map is a TABLE map (its CTA reads "Select on map" vs "Select
+     *  seats"). Only meaningful when `isSeatedEvent`. */
+    tableMapEnabled: boolean;
+    /** The event sells per date/time session — pick a date, then time-slot tickets.
+     *  (Attribute names inferred defensively; pass dates via a prop if your page
+     *  data already has them.) */
+    isTimeSlotEvent: boolean;
+    /** Selectable session dates (ISO `yyyy-mm-dd`) for a time-slot event. */
+    availableDates: string[];
+    /** The event lets a buyer combine MORE THAN ONE ticket type in a single order.
+     *  When false (the default), selecting a new type replaces the previous one —
+     *  the ticket screen enforces one type at a time. Tables and regular tickets
+     *  are mutually exclusive regardless. */
+    allowMultipleTicketTypePurchases: boolean;
+    slug: string | null;
+    name: string | null;
+    /** ISO country code used to seed billing/phone inputs like the storefront. */
+    countryCode: string | null;
+}
+/**
+ * `GET v1/event/:id` — returns what the seated-event handoff needs:
+ * `isSeatedEvent` (core's helper over the event attributes), plus slug/name for
+ * the event-page link. `pk` is the optional preview key for unpublished events.
+ */
+declare const getEventInfo: (eventId: string, pk?: string) => Promise<EventSeatingInfo>;
+/**
+ * Event terms/conditions (client-side gate — nothing is submitted, the server
+ * already knows them). LIVE contract: `attributes` is an ARRAY OF STRINGS, each
+ * a MANDATORY acknowledgement; null when none. The object form
+ * `{ conditions: [{id,name,content,is_required}] }` is tolerated defensively.
+ */
+declare const getEventConditions: (eventId: string) => Promise<EventCondition[]>;
+/**
+ * Ticket types for one DATE of a time-slot (session/calendar) event. Each
+ * returned `id` (matrix_record_id) is specific to the chosen date/session — how
+ * the server knows the date; no date field exists in the add-to-cart body.
+ * @param date "YYYY-MM-DD"
+ * @param options.groupIds restrict to specific slot groups; omit for all.
+ */
+declare const getEventTimeSlotTickets: (eventId: string, date: string, options?: {
+    groupIds?: number[];
+}) => Promise<TicketType[]>;
+/** The event's custom-field groups (order / ticket / add-on scopes). [] when
+ *  the event has none. */
+declare const getEventCustomFields: (eventId: string) => Promise<EventCustomFieldGroup[]>;
+/** Labels of REQUIRED order/ticket custom fields. Fails OPEN ([]) on error. */
+declare const getRequiredCustomFieldLabels: (eventId: string) => Promise<string[]>;
+/** Event add-ons (active only), prices converted from wire cents to units. */
+declare const getEventAddons: (eventId: string) => Promise<EventAddon[]>;
+/**
+ * The web checkout's add-on visibility rule: an add-on applies iff it has no
+ * prerequisite ticket types, or they intersect the cart's DECRYPTED ids. With
+ * no ids yet (cart not primed), returns the list unchanged. Pure — no request.
+ */
+declare const filterAddonsForTickets: (addons: EventAddon[], ticketTypeIds: string[]) => EventAddon[];
+interface TicketCatalogPromoMeta {
+    isPromotionsEnabled: boolean;
+    isAccessCodeEnabled: boolean;
+    promoCodeValid?: boolean;
+    promoCodeMessage?: string;
+}
+/** Tickets plus the catalog-level promo/access metadata the same response
+ *  carries — the read-back half of the promo-code loop. */
+declare const getEventTicketsWithMeta: (eventId: string) => Promise<{
+    tickets: TicketType[];
+    promo: TicketCatalogPromoMeta;
+    showWaitingList: boolean;
+}>;
+/**
+ * Applies a promo/access code to the session (empty string removes it). The
+ * endpoint ALWAYS answers success (anti-brute-force) — read the outcome from a
+ * fresh `getEventTicketsWithMeta` (`promo.promoCodeValid`).
+ */
+declare const submitPromoCode: (eventId: string, promo: string) => Promise<void>;
+/**
+ * Session currency preference (multi-currency events). A bare call geo-seeds and
+ * reports the resolved state; passing a code switches it (every later read
+ * reprices — restart ticket selection after a switch). `{ seed: true }` replays
+ * a carried-over currency without overwriting the buyer's own choice.
+ */
+declare const setEventCurrency: (eventId: string, code?: string, options?: CurrencySyncOptions) => Promise<CurrencyState>;
+/** Unlock a password-protected event. Throws `TtfError` on the wrong password. */
+declare const authenticateEvent: (eventId: string, password: string) => Promise<unknown>;
+/** Fire the event's tracking pixel (page view / order attribution). */
+declare const trackEvent: (eventId: string, options: {
+    pageUrl?: string;
+    page?: string;
+    orderHash?: string;
+}) => Promise<unknown>;
+/** Write ORDER-level custom-field values after the order exists. */
+declare const updateOrderDataCapture: (eventId: string, orderId: string, dataCapture: Record<string, unknown>) => Promise<unknown>;
+/** Write TICKET-level (per-holder) custom-field values for one ticket hash. */
+declare const updateTicketDataCapture: (eventId: string, ticketHash: string, values: Record<string, unknown>) => Promise<unknown>;
+
+interface CreatedOrder {
+    hash: string;
+    total: string;
+    payNow: string;
+    status: string;
+    /** Duplicate-charge guard: true when the server answered with an
+     *  ALREADY-COMPLETED paid order (payment landed out-of-band). Go straight to
+     *  confirmation — never charge again. */
+    alreadyPaid: boolean;
+}
+declare const createOrder: (input: {
+    billing: CheckoutBilling;
+    holders: CheckoutHolder[];
+    addOns: AddonSelection;
+    consent: CheckoutConsent;
+    /** Add-on custom-field values keyed by add-on id → add_on_data_capture. */
+    addOnDataCapture?: Record<string, CustomFieldValues>;
+}) => Promise<CreatedOrder>;
+interface OrderReview {
+    total: string;
+    clientSecret: string | null;
+    publishableKey: string | null;
+    connectedAccount: string | null;
+    expiresInSeconds?: number;
+    paymentAlreadyProcessed: boolean;
+    gateway: ReturnType<typeof detectGateway>;
+    orderId?: string;
+    currency?: string;
+    stripeIntentId?: string;
+    payNow?: string;
+    razorpayKeyId?: string;
+    xenditPublishableKey?: string;
+    xenditOnBehalfOf?: string | null;
+    paymentPlanSetupSecret?: string;
+    paymentPlanSavedCard: SavedPlanCard | null;
+}
+declare const getOrderReview: (orderHash: string) => Promise<OrderReview>;
+/**
+ * Maps a signed-in user's profile into a `CheckoutBilling` to prefill the
+ * billing form. Merge over your own edits:
+ * `setBilling({ ...mapProfileToBilling(profile), ...edits })`.
+ */
+declare const mapProfileToBilling: (profile: TfProfile) => CheckoutBilling;
+declare const completeFreeRegistration: (orderHash: string) => Promise<void>;
+declare const confirmOrderSuccess: (orderHash: string, options?: {
+    /** Razorpay settle token (`razorpay_payment_id`) — the server fetches +
+     *  captures the charge with it. */
+    token?: string;
+}) => Promise<{
+    needIdVerification: boolean;
+}>;
+/**
+ * ID-verification status for a NEED_ID_VERIFICATION order. Pass `mintUrl: true`
+ * on the call that OPENS the provider session (the server mints
+ * `verification_url` on that call only); poll the plain form afterwards.
+ */
+declare const getIdVerificationStatus: (orderHash: string, mintUrl?: boolean) => Promise<IdVerificationStatus>;
+/** Whether the signed-in user owns this order (guards the confirmation page
+ *  against someone opening another buyer's order hash). */
+declare const verifyCustomerOrder: (orderHash: string) => Promise<unknown>;
+
+/** A row in the order history. Fields the platform is known to return are typed;
+ *  the index signature keeps forward-compatible extras accessible. */
+interface TfOrderSummary {
+    id?: string | number;
+    hash?: string;
+    status?: string;
+    total?: string | number;
+    currency?: string;
+    eventName?: string;
+    createdAt?: string;
+    [key: string]: unknown;
+}
+/** A single order's full detail (tickets, buyer, totals). */
+interface TfOrderDetails extends TfOrderSummary {
+    tickets?: unknown[];
+}
+interface OrdersQuery {
+    page?: number;
+    limit?: number;
+    /** Restrict to one event by slug. */
+    eventSlug?: string;
+    /** Restrict to a brand (and its subbrands). */
+    brandSlug?: string;
+}
+/** List the signed-in user's orders, newest first (server-paginated). */
+declare const getOrders: (query?: OrdersQuery) => Promise<TfListEnvelope<TfOrderSummary>>;
+/** The authenticated account endpoint accepts the numeric order id. Public
+ * order hashes belong to the confirmation endpoint and must be resolved first. */
+declare const getOrder: (orderId: string) => Promise<TfEnvelope<TfOrderDetails>>;
+/** The signed-in user's tickets (wallet), server-paginated + filterable. */
+declare const getMyTickets: (query?: OrdersQuery & {
+    from?: string;
+}) => Promise<TfListEnvelope<Record<string, unknown>>>;
+/** Update the order-level data-capture answers shown on the order detail page. */
+declare const updateOrderCustomFields: (eventId: string, orderId: string, values: Record<string, unknown>) => Promise<unknown>;
+/** Update data-capture answers for one issued ticket. */
+declare const updateTicketHolderCustomFields: (eventId: string, ticketHash: string, values: Record<string, unknown>) => Promise<unknown>;
+
+declare const ttf: {
+    readonly auth: {
+        readonly login: (email: string, password: string) => Promise<TfProfile>;
+        readonly register: (fields: Record<string, string | Blob>) => Promise<TfProfile>;
+        readonly registerAccount: (input: AuthRegistrationInput) => Promise<TfProfile>;
+        readonly logout: () => Promise<void>;
+        readonly restorePassword: (email: string) => Promise<void>;
+        readonly restorePasswordRn: (email: string) => Promise<void>;
+        readonly resetPassword: (input: {
+            token: string;
+            password: string;
+            passwordConfirmation?: string;
+        }) => Promise<void>;
+        readonly checkEmailExists: (email: string) => Promise<{
+            exists: boolean;
+            error?: string;
+        }>;
+        readonly mintVerificationUrl: () => Promise<unknown>;
+        readonly getVerificationInfo: () => Promise<unknown>;
+        readonly updateVerificationStatus: () => Promise<unknown>;
+    };
+    readonly profile: {
+        readonly get: () => Promise<TfProfile>;
+    };
+    readonly geo: {
+        readonly countries: () => Promise<TfCountry[]>;
+        readonly states: (countryId: string | number) => Promise<TfState[]>;
+    };
+    readonly events: {
+        readonly tickets: (eventId: string) => Promise<TicketType[]>;
+        readonly ticketsWithMeta: (eventId: string) => Promise<{
+            tickets: TicketType[];
+            promo: TicketCatalogPromoMeta;
+            showWaitingList: boolean;
+        }>;
+        readonly info: (eventId: string, pk?: string) => Promise<EventSeatingInfo>;
+        readonly conditions: (eventId: string) => Promise<EventCondition[]>;
+        readonly timeSlotTickets: (eventId: string, date: string, options?: {
+            groupIds?: number[];
+        }) => Promise<TicketType[]>;
+        readonly customFields: (eventId: string) => Promise<EventCustomFieldGroup[]>;
+        readonly requiredCustomFieldLabels: (eventId: string) => Promise<string[]>;
+        readonly addons: (eventId: string) => Promise<EventAddon[]>;
+        readonly filterAddonsForTickets: (addons: EventAddon[], ticketTypeIds: string[]) => EventAddon[];
+        readonly submitPromoCode: (eventId: string, promo: string) => Promise<void>;
+        readonly setCurrency: (eventId: string, code?: string, options?: CurrencySyncOptions) => Promise<CurrencyState>;
+        readonly authenticate: (eventId: string, password: string) => Promise<unknown>;
+        readonly track: (eventId: string, options: {
+            pageUrl?: string;
+            page?: string;
+            orderHash?: string;
+        }) => Promise<unknown>;
+        readonly updateOrderDataCapture: (eventId: string, orderId: string, dataCapture: Record<string, unknown>) => Promise<unknown>;
+        readonly updateTicketDataCapture: (eventId: string, ticketHash: string, values: Record<string, unknown>) => Promise<unknown>;
+    };
+    readonly cart: {
+        readonly add: (eventId: string, selections: TicketSelection[]) => Promise<{
+            holderNamesRequired: boolean;
+        }>;
+        readonly addSeats: (eventId: string, lines: SeatLine[]) => Promise<{
+            holderNamesRequired: boolean;
+        }>;
+        readonly get: () => Promise<{
+            expiresInSeconds: number;
+            preOrderGateway: string | null;
+        }>;
+        readonly checkoutConfigs: () => Promise<{
+            holderNamesRequired: boolean;
+            fieldGates: BuyerFieldVisibility;
+        }>;
+        readonly price: (eventId: string, addOns: AddonSelection, options?: {
+            isFromResale?: boolean;
+        }) => Promise<CheckoutPricing>;
+        readonly priceBreakdown: (addOns?: AddonSelection) => Promise<PriceBreakdown | null>;
+        readonly paymentConfig: () => Promise<Record<string, unknown>>;
+        readonly preOrderMethods: () => Promise<PreOrderPaymentMethods>;
+        readonly checkBuyerEmail: (email: string) => Promise<ExistingAccount>;
+    };
+    readonly order: {
+        readonly create: (input: {
+            billing: CheckoutBilling;
+            holders: CheckoutHolder[];
+            addOns: AddonSelection;
+            consent: CheckoutConsent;
+            addOnDataCapture?: Record<string, CustomFieldValues>;
+        }) => Promise<CreatedOrder>;
+        readonly review: (orderHash: string) => Promise<OrderReview>;
+        readonly mapProfileToBilling: (profile: TfProfile) => CheckoutBilling;
+        readonly completeFreeRegistration: (orderHash: string) => Promise<void>;
+        readonly confirmSuccess: (orderHash: string, options?: {
+            token?: string;
+        }) => Promise<{
+            needIdVerification: boolean;
+        }>;
+        readonly idVerificationStatus: (orderHash: string, mintUrl?: boolean) => Promise<IdVerificationStatus>;
+        readonly verifyCustomer: (orderHash: string) => Promise<unknown>;
+    };
+    readonly payment: {
+        readonly changeMethodType: (orderHash: string, input: PaymentMethodTypeInput) => Promise<void>;
+        readonly confirmRedirect: (orderHash: string, request: RedirectConfirmRequest) => Promise<RedirectOutcome>;
+        readonly prepareOxxo: (orderHash: string) => Promise<void>;
+        readonly xenditEWalletCharge: (fields: Record<string, string>) => Promise<Record<string, unknown>>;
+        readonly xenditCardCharge: (orderId: string, orderHash: string, token: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        readonly installmentOffers: (orderHash: string, fields: Record<string, string>) => Promise<Record<string, unknown>>;
+        readonly confirmInstallments: (orderHash: string, fields: Record<string, string>) => Promise<Record<string, unknown>>;
+        readonly createPaymentPlan: (orderHash: string, stripePaymentMethodId: string) => Promise<{
+            needIdVerification: boolean;
+        }>;
+        readonly chargeSavedCardPlan: (orderHash: string, paymentMethodId: string) => Promise<{
+            requiresAction: boolean;
+            clientSecret?: string;
+        }>;
+        readonly changeMethod: (attributes: Record<string, unknown>) => Promise<void>;
+        readonly paypalForm: (orderHash: string) => Promise<PayPalForm | null>;
+    };
+    readonly orders: {
+        readonly list: (query?: OrdersQuery) => Promise<TfListEnvelope<TfOrderSummary>>;
+        readonly get: (orderId: string) => Promise<TfEnvelope<TfOrderDetails>>;
+        readonly myTickets: (query?: OrdersQuery & {
+            from?: string;
+        }) => Promise<TfListEnvelope<Record<string, unknown>>>;
+        readonly updateOrderCustomFields: (eventId: string, orderId: string, values: Record<string, unknown>) => Promise<unknown>;
+        readonly updateTicketHolderCustomFields: (eventId: string, ticketHash: string, values: Record<string, unknown>) => Promise<unknown>;
+    };
+    readonly engagement: {
+        readonly attributeReferrer: (eventId: string, referrer: string | number | null) => Promise<void>;
+        readonly joinWaitingList: (eventId: string, entry: WaitingListEntry) => Promise<void>;
+        readonly sendRsvp: (eventId: string, data: Record<string, unknown>) => Promise<unknown>;
+        readonly validatePhone: (phone: string) => Promise<{
+            valid: boolean;
+            [key: string]: unknown;
+        }>;
+    };
+    readonly resale: {
+        readonly sell: (ticketId: string, payload?: Record<string, unknown>) => Promise<unknown>;
+        readonly remove: (ticketId: string) => Promise<unknown>;
+        readonly process: (ticketId: string, payload?: Record<string, unknown>) => Promise<unknown>;
+        readonly decline: (ticketId: string) => Promise<unknown>;
+    };
+    readonly confirmation: {
+        readonly get: (orderHash: string) => Promise<Record<string, unknown>>;
+    };
+    readonly preRegistration: {
+        readonly confirm: (eventId: string, attributes: Record<string, unknown>) => Promise<unknown>;
+        readonly influencers: (eventId: string) => Promise<unknown>;
+        readonly confirmationPage: (hash: string) => Promise<unknown>;
+        readonly submitShareAction: (hash: string, input: {
+            eventActionId: number | string;
+            accessToken?: string;
+            shareActionToken?: string;
+            tokenShuffleMethod?: string;
+            phase?: string;
+        }) => Promise<unknown>;
+    };
+    readonly delegation: {
+        readonly checkCustomerExists: (accessHash: string) => Promise<Record<string, unknown>>;
+        readonly consumerPageInfo: (accessHash: string) => Promise<unknown>;
+        readonly issueTicket: (accessHash: string, data: Record<string, unknown>) => Promise<unknown>;
+    };
+    readonly seatmap: {
+        readonly data: (eventId: string, params?: Record<string, unknown>) => Promise<unknown>;
+        readonly statuses: (eventId: string) => Promise<unknown>;
+        readonly reserve: (eventId: string, reservation: Record<string, unknown>) => Promise<unknown>;
+        readonly removeReserved: (eventId: string, tierId: string, seatIds: string[]) => Promise<unknown>;
+        readonly refreshReservation: (eventId: string, orderId: string) => Promise<unknown>;
+    };
+};
+type Ttf = typeof ttf;
+
+/**
+ * Sign in with email + password. Runs the OAuth chain, stores the tokens, and
+ * resolves to the freshly-loaded profile. Throws `TtfError` on bad credentials.
+ */
+declare const login: (email: string, password: string) => Promise<TfProfile>;
+/**
+ * Create an account. Pass the registration fields as a flat record — the
+ * backend endpoint (`v1/oauth/register-rn`) takes multipart form data, so field
+ * names are forwarded verbatim (`email`, `password`, `first_name`, …).
+ */
+declare const register: (fields: Record<string, string | Blob>) => Promise<TfProfile>;
+/** Typed registration used by platform auth flows. */
+declare const registerAccount: (input: AuthRegistrationInput) => Promise<TfProfile>;
+/** Kick off the "forgot password" email for an address. */
+declare const restorePassword: (email: string) => Promise<void>;
+/** Complete a password reset with the token from the email. */
+declare const resetPassword: (input: {
+    token: string;
+    password: string;
+    passwordConfirmation?: string;
+}) => Promise<void>;
+/** React Native "forgot password" variant (`v1/oauth/restore-password-rn`). */
+declare const restorePasswordRn: (email: string) => Promise<void>;
+/** Mint (or read) the hosted identity-verification URL for the signed-in user. */
+declare const mintVerificationUrl: () => Promise<unknown>;
+/** Read the signed-in user's current identity-verification status. */
+declare const getVerificationInfo: () => Promise<unknown>;
+/** Mark identity verification as PENDING after the buyer starts the provider flow. */
+declare const updateVerificationStatus: () => Promise<unknown>;
+/** Sign out: tell the backend, then drop local tokens regardless of the result. */
+declare const logout: () => Promise<void>;
+/**
+ * Whether an email already has an account. Normalizes the legacy
+ * `/ajax/contact-email` response (`exists: 0|1`) to a boolean; never throws —
+ * returns `{ exists: false }` on failure so callers can treat it as advisory.
+ */
+declare const checkEmailExists: (email: string) => Promise<{
+    exists: boolean;
+    error?: string;
+}>;
+
+/** Fetch the signed-in user's profile. Throws `TtfError` if unauthenticated. */
+declare const getProfile: () => Promise<TfProfile>;
+
+/** All selectable countries (billing `countryId` values). */
+declare const getCountries: () => Promise<TfCountry[]>;
+/** States/provinces for a country, normalized from the backend's id→name map. */
+declare const getStates: (countryId: string | number) => Promise<TfState[]>;
+
+/** Put a ticket up for resale. `payload` carries price/recipient per the event's
+ *  resale rules; forwarded verbatim. */
+declare const sellTicket: (ticketId: string, payload?: Record<string, unknown>) => Promise<unknown>;
+/** Remove a ticket that is currently listed for resale. */
+declare const removeTicketFromResale: (ticketId: string) => Promise<unknown>;
+/** Process (accept/complete) a pending resale for a ticket. */
+declare const processResale: (ticketId: string, payload?: Record<string, unknown>) => Promise<unknown>;
+/** Decline a pending resale for a ticket. */
+declare const declineResale: (ticketId: string) => Promise<unknown>;
+
+/** Fetch the confirmation-page payload for a completed order. */
+declare const getConfirmation: (orderHash: string) => Promise<Record<string, unknown>>;
+
+/** Decode the backend's lightweight pre-registration share-action token. */
+declare const decodeShareActionToken: (value: string, method?: string) => string;
+/** Confirm pre-registration for an event. `attributes` carries the buyer's
+ *  answers; forwarded under the JSON:API `{ data: { attributes } }` envelope. */
+declare const confirmPreRegistration: (eventId: string, attributes: Record<string, unknown>) => Promise<unknown>;
+/** Influencers/promoters available to share to for an event's pre-reg phase. */
+declare const getInfluencers: (eventId: string) => Promise<unknown>;
+/** The post-confirmation share page (options + the buyer's current standing). */
+declare const getConfirmationPage: (hash: string) => Promise<unknown>;
+/** Record a share action (a referral phase step) against a pre-reg hash. */
+declare const submitShareAction: (hash: string, input: {
+    eventActionId: number | string;
+    accessToken?: string;
+    shareActionToken?: string;
+    tokenShuffleMethod?: string;
+    phase?: string;
+}) => Promise<unknown>;
+
+/** Whether the delegated recipient already has an account. */
+declare const checkCustomerExists: (accessHash: string) => Promise<Record<string, unknown>>;
+/** The claim page for a delegation access link (event + ticket context). */
+declare const getConsumerPageInfo: (accessHash: string) => Promise<unknown>;
+/** Issue (claim) the delegated ticket. `data` carries the recipient details;
+ *  forwarded under the JSON:API `{ data: { attributes } }` envelope. */
+declare const issueTicket: (accessHash: string, data: Record<string, unknown>) => Promise<unknown>;
+
+/** The venue seat map for an event (optionally scoped via `params`). */
+declare const getSeatMapData: (eventId: string, params?: Record<string, unknown>) => Promise<unknown>;
+/** Live availability/status for the event's seats (poll during selection). */
+declare const getSeatStatuses: (eventId: string) => Promise<unknown>;
+/** Reserve a seat selection, e.g. `{ tierId, seatId, ttl: 10 }` — forwarded
+ *  under the backend's `{ data: … }` envelope. */
+declare const reserveSeats: (eventId: string, reservation: Record<string, unknown>) => Promise<unknown>;
+/** Release a held reservation (DELETE with a body). */
+declare const removeReservedSeats: (eventId: string, tierId: string, seatIds: string[]) => Promise<unknown>;
+/** Extend a seat reservation's TTL for an in-flight order. */
+declare const refreshReservation: (eventId: string, orderId: string) => Promise<unknown>;
+
+/**
+ * Per-payment-method-type fee re-price (Klarna/Afterpay-class types carry their
+ * own fee structures). Run BEFORE confirming a fee-mode type, then re-fetch the
+ * review — charging the pre-reprice amount would undercharge.
+ */
+declare const changePaymentMethodType: (orderHash: string, input: PaymentMethodTypeInput) => Promise<void>;
+/** Server-side confirm for redirect-based Stripe methods — returns the provider
+ *  hand-off (or 'settled' when no redirect is needed). */
+declare const confirmRedirect: (orderHash: string, request: RedirectConfirmRequest) => Promise<RedirectOutcome>;
+/** OXXO: move the order (and its goods) to the pending-voucher state BEFORE the
+ *  client confirm. Empty body; needs the registered session. */
+declare const prepareForOxxo: (orderHash: string) => Promise<void>;
+/** Xendit e-wallet charge — multipart fields from core's
+ *  `buildXenditEWalletChargeFields`; interpret with `interpretXenditChargeResponse`. */
+declare const submitXenditEWalletCharge: (fields: Record<string, string>) => Promise<Record<string, unknown>>;
+/** MSI offers — between payment-method creation and the confirm; the server
+ *  gates to MXN carts. Fields from `buildInstallmentOffersFields`. */
+declare const getInstallmentOffers: (orderHash: string, fields: Record<string, string>) => Promise<Record<string, unknown>>;
+/** MSI confirm: the intent confirms SERVER-SIDE — when has_next_action comes
+ *  back, run only handleNextAction, never a second confirmPayment. */
+declare const confirmInstallments: (orderHash: string, fields: Record<string, string>) => Promise<Record<string, unknown>>;
+/**
+ * Payment plan (installments) with a NEW card: the card is saved via the
+ * review's SetupIntent (confirmed on the confirmer, nothing charged), then this
+ * schedules the plan server-side against the resulting PaymentMethod.
+ */
+declare const createPaymentPlan: (orderHash: string, stripePaymentMethodId: string) => Promise<{
+    needIdVerification: boolean;
+}>;
+/**
+ * Payment-plan saved-card shortcut: charge the plan directly to the reusable
+ * card the review carries, skipping the SetupIntent round trip. The server may
+ * answer `requires_action` with a client secret — run 3DS, then settle.
+ */
+declare const chargeSavedCardPlan: (orderHash: string, paymentMethodId: string) => Promise<{
+    requiresAction: boolean;
+    clientSecret?: string;
+}>;
+/** PayPal Standard step 1: switch the placed order's payment method (attributes
+ *  from core's `buildChangePaymentMethodAttributes`). */
+declare const changePaymentMethod: (attributes: Record<string, unknown>) => Promise<void>;
+/** PayPal Standard step 2: the `{action_url, fields}` document the provider page
+ *  auto-submits (PayPal refuses framing — top-level POST only). */
+declare const getPayPalForm: (orderHash: string) => Promise<PayPalForm | null>;
+/**
+ * Xendit CARD charge: the sheet tokenized the card (with 3DS) client-side; the
+ * token is charged server-side (the amount is resolved from the order, the
+ * token only proves the card). Success responses may still carry error:true;
+ * that throws here.
+ */
+declare const submitXenditCardCharge: (orderId: string, orderHash: string, token: Record<string, unknown>) => Promise<Record<string, unknown>>;
+
+/**
+ * The raw api surface — one function per endpoint, each "just does the call"
+ * and returns typed data (or throws `TtfError`). The `ttf` facade in
+ * `services.ts` is a thin, domain-grouped convenience over exactly these.
+ * Power users can import them directly.
+ */
+
+type index$1_CheckoutPricing = CheckoutPricing;
+type index$1_CreatedOrder = CreatedOrder;
+type index$1_EventSeatingInfo = EventSeatingInfo;
+type index$1_OrderReview = OrderReview;
+type index$1_OrdersQuery = OrdersQuery;
+type index$1_PreOrderPaymentMethods = PreOrderPaymentMethods;
+type index$1_TfOrderDetails = TfOrderDetails;
+type index$1_TfOrderSummary = TfOrderSummary;
+type index$1_TicketCatalogPromoMeta = TicketCatalogPromoMeta;
+type index$1_WaitingListEntry = WaitingListEntry;
+declare const index$1_addSeatsToCart: typeof addSeatsToCart;
+declare const index$1_addTicketsToCart: typeof addTicketsToCart;
+declare const index$1_attributeReferrer: typeof attributeReferrer;
+declare const index$1_authenticateEvent: typeof authenticateEvent;
+declare const index$1_changePaymentMethod: typeof changePaymentMethod;
+declare const index$1_changePaymentMethodType: typeof changePaymentMethodType;
+declare const index$1_chargeSavedCardPlan: typeof chargeSavedCardPlan;
+declare const index$1_checkBuyerEmail: typeof checkBuyerEmail;
+declare const index$1_checkCustomerExists: typeof checkCustomerExists;
+declare const index$1_checkEmailExists: typeof checkEmailExists;
+declare const index$1_completeFreeRegistration: typeof completeFreeRegistration;
+declare const index$1_confirmInstallments: typeof confirmInstallments;
+declare const index$1_confirmOrderSuccess: typeof confirmOrderSuccess;
+declare const index$1_confirmPreRegistration: typeof confirmPreRegistration;
+declare const index$1_confirmRedirect: typeof confirmRedirect;
+declare const index$1_createOrder: typeof createOrder;
+declare const index$1_createPaymentPlan: typeof createPaymentPlan;
+declare const index$1_declineResale: typeof declineResale;
+declare const index$1_decodeShareActionToken: typeof decodeShareActionToken;
+declare const index$1_filterAddonsForTickets: typeof filterAddonsForTickets;
+declare const index$1_getCart: typeof getCart;
+declare const index$1_getCheckoutConfigs: typeof getCheckoutConfigs;
+declare const index$1_getConfirmation: typeof getConfirmation;
+declare const index$1_getConfirmationPage: typeof getConfirmationPage;
+declare const index$1_getConsumerPageInfo: typeof getConsumerPageInfo;
+declare const index$1_getCountries: typeof getCountries;
+declare const index$1_getEventAddons: typeof getEventAddons;
+declare const index$1_getEventConditions: typeof getEventConditions;
+declare const index$1_getEventCustomFields: typeof getEventCustomFields;
+declare const index$1_getEventInfo: typeof getEventInfo;
+declare const index$1_getEventTickets: typeof getEventTickets;
+declare const index$1_getEventTicketsWithMeta: typeof getEventTicketsWithMeta;
+declare const index$1_getEventTimeSlotTickets: typeof getEventTimeSlotTickets;
+declare const index$1_getIdVerificationStatus: typeof getIdVerificationStatus;
+declare const index$1_getInfluencers: typeof getInfluencers;
+declare const index$1_getInstallmentOffers: typeof getInstallmentOffers;
+declare const index$1_getMyTickets: typeof getMyTickets;
+declare const index$1_getOrder: typeof getOrder;
+declare const index$1_getOrderReview: typeof getOrderReview;
+declare const index$1_getOrders: typeof getOrders;
+declare const index$1_getPayPalForm: typeof getPayPalForm;
+declare const index$1_getPaymentConfigAttributes: typeof getPaymentConfigAttributes;
+declare const index$1_getPreOrderPaymentMethods: typeof getPreOrderPaymentMethods;
+declare const index$1_getPriceBreakdown: typeof getPriceBreakdown;
+declare const index$1_getProfile: typeof getProfile;
+declare const index$1_getRequiredCustomFieldLabels: typeof getRequiredCustomFieldLabels;
+declare const index$1_getSeatMapData: typeof getSeatMapData;
+declare const index$1_getSeatStatuses: typeof getSeatStatuses;
+declare const index$1_getStates: typeof getStates;
+declare const index$1_getVerificationInfo: typeof getVerificationInfo;
+declare const index$1_issueTicket: typeof issueTicket;
+declare const index$1_joinWaitingList: typeof joinWaitingList;
+declare const index$1_login: typeof login;
+declare const index$1_logout: typeof logout;
+declare const index$1_mapProfileToBilling: typeof mapProfileToBilling;
+declare const index$1_mintVerificationUrl: typeof mintVerificationUrl;
+declare const index$1_prepareForOxxo: typeof prepareForOxxo;
+declare const index$1_processResale: typeof processResale;
+declare const index$1_refreshReservation: typeof refreshReservation;
+declare const index$1_register: typeof register;
+declare const index$1_registerAccount: typeof registerAccount;
+declare const index$1_removeReservedSeats: typeof removeReservedSeats;
+declare const index$1_removeTicketFromResale: typeof removeTicketFromResale;
+declare const index$1_reserveSeats: typeof reserveSeats;
+declare const index$1_resetPassword: typeof resetPassword;
+declare const index$1_restorePassword: typeof restorePassword;
+declare const index$1_restorePasswordRn: typeof restorePasswordRn;
+declare const index$1_sellTicket: typeof sellTicket;
+declare const index$1_sendRsvp: typeof sendRsvp;
+declare const index$1_setEventCurrency: typeof setEventCurrency;
+declare const index$1_submitPromoCode: typeof submitPromoCode;
+declare const index$1_submitShareAction: typeof submitShareAction;
+declare const index$1_submitXenditCardCharge: typeof submitXenditCardCharge;
+declare const index$1_submitXenditEWalletCharge: typeof submitXenditEWalletCharge;
+declare const index$1_trackEvent: typeof trackEvent;
+declare const index$1_updateCheckout: typeof updateCheckout;
+declare const index$1_updateOrderCustomFields: typeof updateOrderCustomFields;
+declare const index$1_updateOrderDataCapture: typeof updateOrderDataCapture;
+declare const index$1_updateTicketDataCapture: typeof updateTicketDataCapture;
+declare const index$1_updateTicketHolderCustomFields: typeof updateTicketHolderCustomFields;
+declare const index$1_updateVerificationStatus: typeof updateVerificationStatus;
+declare const index$1_validatePhone: typeof validatePhone;
+declare const index$1_verifyCustomerOrder: typeof verifyCustomerOrder;
+declare namespace index$1 {
+  export { type index$1_CheckoutPricing as CheckoutPricing, type index$1_CreatedOrder as CreatedOrder, type index$1_EventSeatingInfo as EventSeatingInfo, type index$1_OrderReview as OrderReview, type index$1_OrdersQuery as OrdersQuery, type index$1_PreOrderPaymentMethods as PreOrderPaymentMethods, type index$1_TfOrderDetails as TfOrderDetails, type index$1_TfOrderSummary as TfOrderSummary, type index$1_TicketCatalogPromoMeta as TicketCatalogPromoMeta, type index$1_WaitingListEntry as WaitingListEntry, index$1_addSeatsToCart as addSeatsToCart, index$1_addTicketsToCart as addTicketsToCart, index$1_attributeReferrer as attributeReferrer, index$1_authenticateEvent as authenticateEvent, index$1_changePaymentMethod as changePaymentMethod, index$1_changePaymentMethodType as changePaymentMethodType, index$1_chargeSavedCardPlan as chargeSavedCardPlan, index$1_checkBuyerEmail as checkBuyerEmail, index$1_checkCustomerExists as checkCustomerExists, index$1_checkEmailExists as checkEmailExists, index$1_completeFreeRegistration as completeFreeRegistration, index$1_confirmInstallments as confirmInstallments, index$1_confirmOrderSuccess as confirmOrderSuccess, index$1_confirmPreRegistration as confirmPreRegistration, index$1_confirmRedirect as confirmRedirect, index$1_createOrder as createOrder, index$1_createPaymentPlan as createPaymentPlan, index$1_declineResale as declineResale, index$1_decodeShareActionToken as decodeShareActionToken, index$1_filterAddonsForTickets as filterAddonsForTickets, index$1_getCart as getCart, index$1_getCheckoutConfigs as getCheckoutConfigs, index$1_getConfirmation as getConfirmation, index$1_getConfirmationPage as getConfirmationPage, index$1_getConsumerPageInfo as getConsumerPageInfo, index$1_getCountries as getCountries, index$1_getEventAddons as getEventAddons, index$1_getEventConditions as getEventConditions, index$1_getEventCustomFields as getEventCustomFields, index$1_getEventInfo as getEventInfo, index$1_getEventTickets as getEventTickets, index$1_getEventTicketsWithMeta as getEventTicketsWithMeta, index$1_getEventTimeSlotTickets as getEventTimeSlotTickets, index$1_getIdVerificationStatus as getIdVerificationStatus, index$1_getInfluencers as getInfluencers, index$1_getInstallmentOffers as getInstallmentOffers, index$1_getMyTickets as getMyTickets, index$1_getOrder as getOrder, index$1_getOrderReview as getOrderReview, index$1_getOrders as getOrders, index$1_getPayPalForm as getPayPalForm, index$1_getPaymentConfigAttributes as getPaymentConfigAttributes, index$1_getPreOrderPaymentMethods as getPreOrderPaymentMethods, index$1_getPriceBreakdown as getPriceBreakdown, index$1_getProfile as getProfile, index$1_getRequiredCustomFieldLabels as getRequiredCustomFieldLabels, index$1_getSeatMapData as getSeatMapData, index$1_getSeatStatuses as getSeatStatuses, index$1_getStates as getStates, index$1_getVerificationInfo as getVerificationInfo, index$1_issueTicket as issueTicket, index$1_joinWaitingList as joinWaitingList, index$1_login as login, index$1_logout as logout, index$1_mapProfileToBilling as mapProfileToBilling, index$1_mintVerificationUrl as mintVerificationUrl, index$1_prepareForOxxo as prepareForOxxo, index$1_processResale as processResale, index$1_refreshReservation as refreshReservation, index$1_register as register, index$1_registerAccount as registerAccount, index$1_removeReservedSeats as removeReservedSeats, index$1_removeTicketFromResale as removeTicketFromResale, index$1_reserveSeats as reserveSeats, index$1_resetPassword as resetPassword, index$1_restorePassword as restorePassword, index$1_restorePasswordRn as restorePasswordRn, index$1_sellTicket as sellTicket, index$1_sendRsvp as sendRsvp, index$1_setEventCurrency as setEventCurrency, index$1_submitPromoCode as submitPromoCode, index$1_submitShareAction as submitShareAction, index$1_submitXenditCardCharge as submitXenditCardCharge, index$1_submitXenditEWalletCharge as submitXenditEWalletCharge, index$1_trackEvent as trackEvent, index$1_updateCheckout as updateCheckout, index$1_updateOrderCustomFields as updateOrderCustomFields, index$1_updateOrderDataCapture as updateOrderDataCapture, index$1_updateTicketDataCapture as updateTicketDataCapture, index$1_updateTicketHolderCustomFields as updateTicketHolderCustomFields, index$1_updateVerificationStatus as updateVerificationStatus, index$1_validatePhone as validatePhone, index$1_verifyCustomerOrder as verifyCustomerOrder };
+}
+
+/**
+ * Shared option shapes so every hook takes the same `options` passthrough
+ * (onSuccess, enabled, staleTime, …) without re-spelling the generics.
+ */
+
+/** Query options minus the parts the hook owns (`queryKey`, `queryFn`). */
+type QueryOpts<TData> = Omit<UseQueryOptions<TData, TtfError, TData>, 'queryKey' | 'queryFn'>;
+/** Mutation options minus the part the hook owns (`mutationFn`). */
+type MutationOpts<TData, TVars> = Omit<UseMutationOptions<TData, TtfError, TVars>, 'mutationFn'>;
+
+declare const useLogin: (options?: MutationOpts<TfProfile, {
+    email: string;
+    password: string;
+}>) => _tanstack_react_query.UseMutationResult<TfProfile, TtfError, {
+    email: string;
+    password: string;
+}, unknown>;
+declare const useRegister: (options?: MutationOpts<TfProfile, Record<string, string | Blob>>) => _tanstack_react_query.UseMutationResult<TfProfile, TtfError, Record<string, string | Blob>, unknown>;
+declare const useRegisterAccount: (options?: MutationOpts<TfProfile, AuthRegistrationInput>) => _tanstack_react_query.UseMutationResult<TfProfile, TtfError, AuthRegistrationInput, unknown>;
+declare const useRestorePassword: (options?: MutationOpts<void, string>) => _tanstack_react_query.UseMutationResult<void, TtfError, string, unknown>;
+declare const useRestorePasswordRn: (options?: MutationOpts<void, string>) => _tanstack_react_query.UseMutationResult<void, TtfError, string, unknown>;
+declare const useResetPassword: (options?: MutationOpts<void, {
+    token: string;
+    password: string;
+    passwordConfirmation?: string;
+}>) => _tanstack_react_query.UseMutationResult<void, TtfError, {
+    token: string;
+    password: string;
+    passwordConfirmation?: string;
+}, unknown>;
+declare const useLogout: (options?: MutationOpts<void, void>) => _tanstack_react_query.UseMutationResult<void, TtfError, void, unknown>;
+declare const useCheckEmailExists: (options?: MutationOpts<{
+    exists: boolean;
+    error?: string;
+}, string>) => _tanstack_react_query.UseMutationResult<{
+    exists: boolean;
+    error?: string;
+}, TtfError, string, unknown>;
+
+interface UseAuthFlowOptions {
+    initialView?: AuthFlowView;
+    initialEmail?: string;
+    /** Match the legacy modal's full account form by default. */
+    requireRegistrationAddress?: boolean;
+    /** Web and native use different restore-password routes on the legacy API. */
+    passwordResetTransport?: 'web' | 'native';
+    /** Extra backend fields for specialized registration links. */
+    registrationFields?: Record<string, string>;
+    onAuthenticated?: (profile: TfProfile) => void;
+    onLoggedOut?: () => void;
+}
+interface RegistrationSubmitOptions {
+    /** Require state only when the selected country actually exposes states. */
+    requireState?: boolean;
+}
+declare const useAuthFlow: (options?: UseAuthFlowOptions) => {
+    view: AuthFlowView;
+    suggestedEmail: string;
+    fieldErrors: Partial<Record<AuthFieldName, string>>;
+    error: string;
+    successMessage: string;
+    isAuthenticated: boolean;
+    isSubmitting: boolean;
+    showLogin: (email?: string) => void;
+    showRegister: (email?: string) => void;
+    showForgotPassword: (email?: string) => void;
+    clearFeedback: () => void;
+    clearFieldError: (field: AuthFieldName) => void;
+    submitLogin: (input: AuthLoginInput) => Promise<TfProfile | null>;
+    submitRegistration: (input: AuthRegistrationInput, submitOptions?: RegistrationSubmitOptions) => Promise<TfProfile | null>;
+    submitPasswordReset: (email: string) => Promise<boolean>;
+    logout: () => Promise<boolean>;
+    mutations: {
+        login: _tanstack_react_query.UseMutationResult<TfProfile, TtfError, {
+            email: string;
+            password: string;
+        }, unknown>;
+        register: _tanstack_react_query.UseMutationResult<TfProfile, TtfError, AuthRegistrationInput, unknown>;
+        restorePassword: _tanstack_react_query.UseMutationResult<void, TtfError, string, unknown>;
+        restorePasswordNative: _tanstack_react_query.UseMutationResult<void, TtfError, string, unknown>;
+        logout: _tanstack_react_query.UseMutationResult<void, TtfError, void, unknown>;
+    };
+};
+type UseAuthFlow = ReturnType<typeof useAuthFlow>;
+
+declare const useAuthSession: () => {
+    isAuthenticated: boolean;
+};
+
+declare const useProfile: (options?: QueryOpts<TfProfile>) => _tanstack_react_query.UseQueryResult<TfProfile, TtfError>;
+
+declare const useCountries: (options?: QueryOpts<TfCountry[]>) => _tanstack_react_query.UseQueryResult<TfCountry[], TtfError>;
+declare const useStates: (countryId: string | number | undefined, options?: QueryOpts<TfState[]>) => _tanstack_react_query.UseQueryResult<TfState[], TtfError>;
+
+/** Event details (seated detection, slug, name). Gated on a chosen event id. */
+declare const useEvent: (eventId: string | undefined, options?: QueryOpts<Awaited<ReturnType<typeof ttf.events.info>>>) => _tanstack_react_query.UseQueryResult<EventSeatingInfo, TtfError>;
+/** Purchasable ticket types for an event. Gated on a chosen event id. */
+declare const useTickets: (eventId: string | undefined, options?: QueryOpts<TicketType[]>) => _tanstack_react_query.UseQueryResult<TicketType[], TtfError>;
+/** Tickets PLUS the catalog-level promo/access-code metadata and waiting-list
+ *  flag the same response carries. Use this (over `useTickets`) when the ticket
+ *  screen needs promo codes, access codes, or waiting lists. `refetch()` after
+ *  applying a code to pick up updated prices / newly-unlocked tickets. */
+declare const useTicketsWithMeta: (eventId: string | undefined, options?: QueryOpts<Awaited<ReturnType<typeof ttf.events.ticketsWithMeta>>>) => _tanstack_react_query.UseQueryResult<{
+    tickets: TicketType[];
+    promo: TicketCatalogPromoMeta;
+    showWaitingList: boolean;
+}, TtfError>;
+/** Purchasable ticket types for ONE date of a time-slot / calendar event. Each
+ *  ticket carries its `timeSlot: { date, time }`. Gated on event id + date. */
+declare const useTimeSlotTickets: (eventId: string | undefined, date: string | undefined, options?: QueryOpts<TicketType[]>) => _tanstack_react_query.UseQueryResult<TicketType[], TtfError>;
+/** The event's add-on catalog (upsells). Gated on a chosen event id. Filter it
+ *  to the primed cart with `ttf.events.filterAddonsForTickets(list, ids)`. */
+declare const useEventAddons: (eventId: string | undefined, options?: QueryOpts<EventAddon[]>) => _tanstack_react_query.UseQueryResult<EventAddon[], TtfError>;
+
+declare const useOrders: (query?: OrdersQuery, options?: QueryOpts<TfListEnvelope<TfOrderSummary>>) => _tanstack_react_query.UseQueryResult<TfListEnvelope<TfOrderSummary>, TtfError>;
+declare const useOrder: (orderId: string | undefined, options?: QueryOpts<TfEnvelope<TfOrderDetails>>) => _tanstack_react_query.UseQueryResult<TfEnvelope<TfOrderDetails>, TtfError>;
+
+declare const useValidatePhone: (options?: MutationOpts<{
+    valid: boolean;
+    [key: string]: unknown;
+}, string>) => _tanstack_react_query.UseMutationResult<{
+    [key: string]: unknown;
+    valid: boolean;
+}, TtfError, string, unknown>;
+declare const useJoinWaitingList: (eventId: string, options?: MutationOpts<void, WaitingListEntry>) => _tanstack_react_query.UseMutationResult<void, TtfError, WaitingListEntry, unknown>;
+declare const useAttributeReferrer: (eventId: string, options?: MutationOpts<void, string | number | null>) => _tanstack_react_query.UseMutationResult<void, TtfError, string | number | null, unknown>;
+declare const useSendRsvp: (eventId: string, options?: MutationOpts<unknown, Record<string, unknown>>) => _tanstack_react_query.UseMutationResult<unknown, TtfError, Record<string, unknown>, unknown>;
+
+interface PlaceOrderHookOptions {
+    /** After a successful order needing ID verification, run it automatically
+     *  (mint + open + poll). The rejection is swallowed — payment already
+     *  settled — so it never surfaces as a payment failure. Uses the engine's
+     *  `openUrl` port to open the provider URL. */
+    autoRunIdVerification?: boolean;
+    idVerification?: RunIdVerificationOptions;
+}
+/**
+ * A gated buyer field this event asks for BEYOND name/email — surfaced from the
+ * server's checkout-configs so consumers render exactly what's needed instead of
+ * guessing. Write the captured value straight to `billing[key]` (e.g.
+ * `setBilling({ ...billing, instagramHandle })`); the engine forwards it in the
+ * order body. `nationality` expects a country id (see `ttf.geo.countries()` /
+ * `useCountries()`); `gender` expects `'M'` | `'F'`.
+ */
+interface BuyerFieldSpec {
+    key: 'nationality' | 'gender' | 'instagramHandle';
+    label: string;
+    required: boolean;
+    /** How to render it: a country picker, an M/F choice, or a handle text box. */
+    kind: 'nationality' | 'gender' | 'instagram';
+}
+interface UseCheckout extends CheckoutSnapshot {
+    /** The whole snapshot object (the fields above are spread from it). */
+    snapshot: CheckoutSnapshot;
+    /** True while a cart/order operation is in flight. */
+    isBusy: boolean;
+    /** Whole-seconds countdown for the cart reservation (undefined when none).
+     *  Raw on purpose — format it however your UI wants. */
+    secondsLeft?: number;
+    /** Required add-on names still missing (same rule the pre-flight enforces). */
+    missingRequiredAddonNames: string[];
+    /** Gated buyer fields this event needs beyond name/email (Instagram /
+     *  nationality / gender), each with its required flag — render these from
+     *  data. Empty when the event gates none. Pairs with `customFields` (the
+     *  order/ticket capture groups) for the full "what must I collect" picture. */
+    buyerFields: BuyerFieldSpec[];
+    /** Whether a signed-in access token is present. */
+    isLoggedIn: boolean;
+    /** Build + price the cart for a ticket selection (alias for `prime`). */
+    setTickets: (eventId: string, selections: TicketSelection[]) => Promise<void>;
+    /** Build + price the cart for reserved SEATS (alias for `primeSeats`). */
+    setSeats: (eventId: string, lines: SeatLine[]) => Promise<void>;
+    /** Attach to an existing server-side cart (e.g. accepted resale invitation). */
+    resumeCart: CheckoutEngine['resumeCart'];
+    setAddons: CheckoutEngine['setAddons'];
+    setBilling: CheckoutEngine['setBilling'];
+    setHolders: CheckoutEngine['setHolders'];
+    setConsent: CheckoutEngine['setConsent'];
+    setAcceptedConditions: CheckoutEngine['setAcceptedConditions'];
+    /** Accept/unaccept one condition block (merges into the map). */
+    acceptCondition: (id: string, accepted: boolean) => void;
+    setAddonDataCapture: CheckoutEngine['setAddonDataCapture'];
+    checkBuyerEmail: CheckoutEngine['checkBuyerEmail'];
+    placeOrder: (method?: PaymentMethod | PaymentRequest, options?: PlaceOrderHookOptions) => Promise<PlaceOrderResult>;
+    runIdVerification: CheckoutEngine['runIdVerification'];
+    syncCurrency: CheckoutEngine['syncCurrency'];
+    reset: CheckoutEngine['reset'];
+    applyPromoCode: (eventId: string, promo: string) => Promise<void>;
+    attributeReferrer: (eventId: string, referrer: string | number | null) => Promise<void>;
+    joinWaitingList: (eventId: string, entry: WaitingListEntry) => Promise<void>;
+}
+declare const useCheckout$1: (config: EngineConfig) => UseCheckout;
+
+/** React Query cache keys for the SDK, all namespaced under `ttf`. */
+
+declare const ttfKeys: {
+    profile: readonly ["ttf", "profile"];
+    countries: readonly ["ttf", "countries"];
+    states: (countryId: string | number) => readonly ["ttf", "states", string | number];
+    event: (eventId: string) => readonly ["ttf", "event", string];
+    tickets: (eventId: string) => readonly ["ttf", "tickets", string];
+    addons: (eventId: string) => readonly ["ttf", "addons", string];
+    orders: (query: OrdersQuery) => readonly ["ttf", "orders", OrdersQuery];
+    order: (orderId: string) => readonly ["ttf", "order", string];
+};
+
+/**
+ * React hooks over the `ttf` facade — one authored copy, imported unchanged by
+ * both platform packages. React and @tanstack/react-query are peer deps, so a
+ * consumer supplies its own QueryClientProvider.
+ */
+
+type index_BuyerFieldSpec = BuyerFieldSpec;
+type index_MutationOpts<TData, TVars> = MutationOpts<TData, TVars>;
+type index_PlaceOrderHookOptions = PlaceOrderHookOptions;
+type index_QueryOpts<TData> = QueryOpts<TData>;
+type index_RegistrationSubmitOptions = RegistrationSubmitOptions;
+type index_UseAuthFlow = UseAuthFlow;
+type index_UseAuthFlowOptions = UseAuthFlowOptions;
+type index_UseCheckout = UseCheckout;
+declare const index_ttfKeys: typeof ttfKeys;
+declare const index_useAttributeReferrer: typeof useAttributeReferrer;
+declare const index_useAuthFlow: typeof useAuthFlow;
+declare const index_useAuthSession: typeof useAuthSession;
+declare const index_useCheckEmailExists: typeof useCheckEmailExists;
+declare const index_useCountries: typeof useCountries;
+declare const index_useEvent: typeof useEvent;
+declare const index_useEventAddons: typeof useEventAddons;
+declare const index_useJoinWaitingList: typeof useJoinWaitingList;
+declare const index_useLogin: typeof useLogin;
+declare const index_useLogout: typeof useLogout;
+declare const index_useOrder: typeof useOrder;
+declare const index_useOrders: typeof useOrders;
+declare const index_useProfile: typeof useProfile;
+declare const index_useRegister: typeof useRegister;
+declare const index_useRegisterAccount: typeof useRegisterAccount;
+declare const index_useResetPassword: typeof useResetPassword;
+declare const index_useRestorePassword: typeof useRestorePassword;
+declare const index_useRestorePasswordRn: typeof useRestorePasswordRn;
+declare const index_useSendRsvp: typeof useSendRsvp;
+declare const index_useStates: typeof useStates;
+declare const index_useTickets: typeof useTickets;
+declare const index_useTicketsWithMeta: typeof useTicketsWithMeta;
+declare const index_useTimeSlotTickets: typeof useTimeSlotTickets;
+declare const index_useValidatePhone: typeof useValidatePhone;
+declare namespace index {
+  export { type index_BuyerFieldSpec as BuyerFieldSpec, type index_MutationOpts as MutationOpts, type index_PlaceOrderHookOptions as PlaceOrderHookOptions, type index_QueryOpts as QueryOpts, type index_RegistrationSubmitOptions as RegistrationSubmitOptions, type index_UseAuthFlow as UseAuthFlow, type index_UseAuthFlowOptions as UseAuthFlowOptions, type index_UseCheckout as UseCheckout, index_ttfKeys as ttfKeys, index_useAttributeReferrer as useAttributeReferrer, index_useAuthFlow as useAuthFlow, index_useAuthSession as useAuthSession, index_useCheckEmailExists as useCheckEmailExists, useCheckout$1 as useCheckout, index_useCountries as useCountries, index_useEvent as useEvent, index_useEventAddons as useEventAddons, index_useJoinWaitingList as useJoinWaitingList, index_useLogin as useLogin, index_useLogout as useLogout, index_useOrder as useOrder, index_useOrders as useOrders, index_useProfile as useProfile, index_useRegister as useRegister, index_useRegisterAccount as useRegisterAccount, index_useResetPassword as useResetPassword, index_useRestorePassword as useRestorePassword, index_useRestorePasswordRn as useRestorePasswordRn, index_useSendRsvp as useSendRsvp, index_useStates as useStates, index_useTickets as useTickets, index_useTicketsWithMeta as useTicketsWithMeta, index_useTimeSlotTickets as useTimeSlotTickets, index_useValidatePhone as useValidatePhone };
+}
+
+/**
+ * Localization types for the checkout SDK.
+ *
+ * Lives in the shared core, not the web layer, so that web and native resolve
+ * strings the same way — the same argument as validation and gating rules.
+ *
+ * Deliberately NOT built on i18next: this package ships with `axios` as its
+ * only dependency and is bundled into React Native, where pulling in a full
+ * i18n runtime would be a tax on every consumer. The resolver in ./resolve.ts
+ * is ~40 lines and covers what checkout copy actually needs (lookup, fallback,
+ * {{var}} interpolation).
+ */
+/** Locale codes the SDK ships, matching the dashboard and the storefront. */
+type LocaleCode = 'en-GB' | 'en-US' | 'es-MX' | 'fr' | 'de' | 'ru' | 'id';
+/**
+ * A flat, dot-notation message catalogue.
+ *
+ * Flat rather than nested so a host can override a single string without
+ * reproducing the surrounding object, and so the key set is trivially
+ * diffable between locales.
+ */
+type Messages = Record<string, string>;
+/** Values interpolated into `{{placeholders}}`. */
+type TranslateVars = Record<string, string | number>;
+/**
+ * Resolves a key to display text. Always returns a string: an unknown key
+ * falls back through the locale chain to English, and finally to the key
+ * itself, so a missing translation can never render blank.
+ */
+type Translate = (key: string, vars?: TranslateVars) => string;
+interface TranslatorOptions {
+    /** Defaults to `en-GB`. */
+    locale?: LocaleCode;
+    /**
+     * Host-supplied overrides, merged over the resolved locale. Lets a brand
+     * reword individual strings ("Tickets" -> "Passes") without forking the SDK
+     * or shipping a whole catalogue.
+     */
+    messages?: Partial<Messages>;
+}
+
+/**
+ * English (UK) — the source of truth.
+ *
+ * Every key the SDK renders exists here, so a translator's job is to copy this
+ * file and translate values; nothing else needs discovering. Other locales may
+ * be partial and resolve missing keys through the chain in ../resolve.ts.
+ *
+ * Keys are namespaced by surface (`auth.`, `billing.`, `tickets.`, …) so a host
+ * overriding one area does not have to know the whole catalogue. Values are the
+ * strings the components previously hard-coded, moved verbatim — this file is a
+ * relocation, not a rewrite, so behaviour is unchanged for anyone who never
+ * sets a locale.
+ */
+declare const en: Messages;
+
+/**
+ * Spanish (Mexico).
+ *
+ * Partial catalogues are legal — anything absent resolves through en-GB — but
+ * this one is complete against ./en.ts so the checkout reads fully Spanish for
+ * the storefronts that need it today.
+ */
+declare const esMX: Messages;
+
+/** Register a locale bundle. Used by ./locales/index to avoid a load cycle. */
+declare const registerCatalogue: (locale: LocaleCode, messages: Messages) => void;
+declare const DEFAULT_LOCALE: LocaleCode;
+/** Map a raw device/browser language onto a locale we ship. */
+declare const resolveLocale: (raw?: string | null) => LocaleCode;
+/**
+ * Build a translator.
+ *
+ * Resolution order: host overrides -> requested locale -> its fallback chain
+ * -> English -> the key itself. The last step means a missing string surfaces
+ * as a visible key rather than an empty element, which is far easier to spot
+ * in review than a silent blank.
+ */
+declare const createTranslator: (options?: TranslatorOptions) => Translate;
+
+/**
+ * Web `useCheckout` — a thin injector: the SDK's `useCheckout` with the web
+ * platform ports pre-wired (Stripe confirmer, popup provider page, inline
+ * Xendit). ALL the DX (countdown, isBusy, promo/referrer/waiting-list, auto ID
+ * verification, the flat snapshot) lives in the SDK's hook, so web and React
+ * Native share it — this file only supplies what's browser-specific.
+ *
+ *   configureCheckout({ env: 'PROD', clientId, clientSecret })  // once, at app start
+ *   const checkout = useCheckout()
+ *   await checkout.setTickets(eventId, selections)
+ *   checkout.setBilling(b)
+ *   await checkout.placeOrder('card')                           // <CardInput/> rendered
+ */
+
+interface UseCheckoutOptions {
+    /** Extra platform ports merged over the web defaults — e.g. MSI's
+     *  `onInstallmentOffers` picker. Read once, at first render. */
+    ports?: Omit<CheckoutPorts, 'confirmer'>;
+    /** Wallet/redirect engine options (merchant identity, redirect URL). */
+    options?: CheckoutOptions;
+}
+declare const useCheckout: (opts?: UseCheckoutOptions) => UseCheckout;
+
+/**
+ * One-time SDK setup for the web. Wraps the shared `configure()` and defaults
+ * the storage adapter to `localStorage` (SSR-safe — no-ops on the server). Call
+ * once at app start, before any `useCheckout`/`ttf` call:
+ *
+ *   configureCheckout({ env: 'PROD', clientId, clientSecret })
+ */
+
+/** localStorage-backed token storage. No-ops on the server (SSR). */
+declare const localStorageAdapter: StorageAdapter;
+declare const configureCheckout: (config: TtfConfig) => void;
+
+/**
+ * The card fields. `<CardInput/>` mounts a Stripe Element as soon as the engine
+ * has initialized Stripe (via the confirmer's `whenReady()` — no races, renders
+ * before or after init) and registers it with the confirmer. `<XenditCardInput/>`
+ * is the inline, formatted equivalent for Xendit events.
+ */
+
+/**
+ * The Stripe card field. Mounts against the engine's Stripe instance and
+ * registers itself with the confirmer; unregisters on unmount.
+ *
+ * Stripe Elements live in a cross-origin iframe and DON'T inherit page CSS, so
+ * by default they render black text — invisible on a dark surface. We read the
+ * host element's computed color/font and feed them to the Element so it matches
+ * whatever theme the consumer uses, no config needed. Pass `style` to override.
+ */
+declare const CardInput: FC<{
+    className?: string;
+    /** Stripe base-style overrides, merged onto the inherited color/font. */
+    style?: StripeCardElementOptions['style'];
+}>;
+/**
+ * The wallet-capable card widget — a Stripe **Payment Element** in DEFERRED mode,
+ * exactly how the OLD checkout rendered payment. It shows the card fields AND,
+ * when the event's `stripe_wallets` gate is on, the Apple Pay / Google Pay
+ * buttons that the buyer picks *inside* the widget. There is no separate "Apple
+ * Pay" method row — wallets are a property of the card widget, as in old.
+ *
+ * Confirmation rides the same `placeOrder({ method: 'card' })` rail: this mounts
+ * the Elements group and registers it with the confirmer, whose `confirmCard`
+ * then runs `elements.submit()` + `stripe.confirmPayment` (old
+ * `useStripePayment.processPayment`). Mount this instead of `<CardInput/>` for a
+ * Stripe event with wallets available — see `<Payment/>`. It needs the server's
+ * deferred Elements config (`checkout.stripeElementsConfig`: mode/amount/currency).
+ */
+declare const StripePaymentElement: FC<{
+    className?: string;
+    /** Server deferred Elements config from `checkout.stripeElementsConfig`. */
+    elementsConfig?: Record<string, unknown>;
+    /** Wallet gate from `checkout.walletAvailability`. */
+    wallets?: {
+        applePay?: boolean;
+        googlePay?: boolean;
+    };
+    /** Extra Payment Element options, merged over the wallet gate. */
+    options?: StripePaymentElementOptions;
+}>;
+/**
+ * Inline card field for a Xendit event — the formatted, no-popup equivalent of
+ * `<CardInput/>`. Render it when the gateway is Xendit and the buyer picks card,
+ * then `placeOrder({ method: 'xenditCard' })`: the engine tokenizes these fields
+ * with xendit.js (3DS inline) and charges server-side.
+ */
+declare const XenditCardInput: FC<{
+    className?: string;
+    inputClassName?: string;
+    /**
+     * Reports the current field-level problem (or null when the fields are fine).
+     * The message is deliberately NOT rendered here: this component is mounted
+     * inside the consumer's bordered card box, and an error printed in there sits
+     * inside the border instead of beneath it. The consumer places it — see
+     * `<Payment/>`, which renders it under the box like every other field error.
+     */
+    onValidationChange?: (message: string | null) => void;
+}>;
+
+/**
+ * The checkout theme — a structured, documented token set. Pass any subset to
+ * `<CheckoutProvider theme={…}>`; each token maps to a `--tf-checkout-*` CSS
+ * custom property that `checkout.css` (and every component) reads. Anything you
+ * omit falls back to the stylesheet default.
+ */
+
+interface CheckoutTheme {
+    /** `'dark'` adds the `tf-checkout--dark` class (dark default palette). */
+    colorScheme?: 'light' | 'dark';
+    /** Primary color — buttons, step badges, focus ring, links. */
+    accent?: string;
+    /** Hover state for `accent` (defaults near `accent`). */
+    accentHover?: string;
+    /** Text/icon color on top of `accent`. */
+    accentContrast?: string;
+    /** Card background. */
+    surface?: string;
+    /** Subtle fill (summary rows, muted pills). */
+    surfaceMuted?: string;
+    /** Primary text. */
+    text?: string;
+    /** Secondary text (labels, "incl. fees", hints). */
+    muted?: string;
+    /** Borders + dividers. */
+    border?: string;
+    /** Error text + invalid field borders. */
+    error?: string;
+    /** Success (confirmation check). */
+    success?: string;
+    /** Corner radius for cards. */
+    radiusCard?: string;
+    /** Corner radius for inputs / buttons. */
+    radiusControl?: string;
+    /** Card shadow. */
+    shadow?: string;
+    /** Font family for the whole component tree. */
+    font?: string;
+    /** Base font size (e.g. `15px`). */
+    fontSize?: string;
+    /** Max width of the checkout column. */
+    maxWidth?: string;
+}
+/** Turn a theme into inline `--tf-checkout-*` custom properties for the root. */
+declare const themeToVars: (theme?: CheckoutTheme) => CSSProperties;
+
+/**
+ * `<CheckoutProvider>` — wrap your checkout UI once. It:
+ *   - provides the checkout to every section via context — so `<Tickets/>`,
+ *     `<Payment/>`, … just read it, no prop-drilling. By default it runs
+ *     `useCheckout()` for you (the web-wired engine: Stripe/Xendit + shared
+ *     store); pass your own instance as `value` to bring your own;
+ *   - applies the `theme` as `--tf-checkout-*` CSS variables on its root and
+ *     scopes all styles under `.tf-checkout`.
+ *
+ * This is the single styling + context boundary shared by all three usage
+ * tiers: the batteries-included `<EmbeddedCheckout/>`, à-la-carte sections, and (via
+ * `value`) a consumer who already holds a `useCheckout()` of their own.
+ *
+ * Styles load automatically from the package entry point.
+ */
+
+interface CheckoutProviderProps {
+    /**
+     * Bring your own checkout instance (from a top-level `useCheckout()`). Omit
+     * and the provider runs `useCheckout()` itself. Either way the sections read
+     * the same shared cart (the engine store is a module singleton).
+     */
+    value?: UseCheckout;
+    /** Retheme via design tokens. */
+    theme?: CheckoutTheme;
+    /**
+     * Language for the checkout's own copy. Defaults to `en-GB`, so omitting it
+     * leaves every existing consumer's rendering byte-for-byte unchanged.
+     */
+    locale?: LocaleCode;
+    /**
+     * Per-key overrides merged over the locale, for brands that need to reword
+     * individual strings without shipping a whole catalogue.
+     */
+    messages?: Partial<Messages>;
+    /** Extra class on the `.tf-checkout` root. */
+    className?: string;
+    children: ReactNode;
+}
+declare const CheckoutProvider: FC<CheckoutProviderProps>;
+/** Read the shared checkout inside any component under `<CheckoutProvider>`. */
+declare const useCheckoutContext: () => UseCheckout;
+/** Coordinate submit-attempt validation across separately composed sections. */
+declare const useCheckoutValidation: () => {
+    attempt: number;
+    requestValidation: () => void;
+};
+
+/** Join truthy class names (tiny, dependency-free). */
+declare const cx: (...parts: Array<string | false | null | undefined>) => string;
+
+/**
+ * `Card` + `SectionHeader` — the shell every checkout section shares: a rounded
+ * surface with a numbered step badge, a title, and optional right-aligned pills
+ * (totals, a countdown, a loading chip). Keeps all sections visually identical
+ * without each re-authoring the header markup.
+ */
+
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    className?: string;
+}
+/** A themed surface (`.tf-checkout-card`). Spreads through any div props. */
+declare const Card: FC<CardProps>;
+interface SectionHeaderProps {
+    /** Badge content — a step number, an icon, `✓`. Omit for no badge. */
+    step?: ReactNode;
+    title: ReactNode;
+    /** Right-aligned chips (total, timer, "loading…"). */
+    pills?: ReactNode;
+    className?: string;
+}
+declare const SectionHeader: FC<SectionHeaderProps>;
+/** A single right-aligned chip for a `SectionHeader`'s `pills`. */
+declare const Pill: FC<{
+    muted?: boolean;
+    children: ReactNode;
+}>;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Visual weight. */
+    variant?: 'primary' | 'secondary' | 'ghost';
+    /** Stretch to full width. */
+    block?: boolean;
+    /** Show a spinner and disable. */
+    loading?: boolean;
+}
+/** The one shared button — token-driven variants, loading state, `className`. */
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+/** Labeled wrapper — owns the label + error row so controls stay consistent. */
+declare const Field: FC<{
+    label?: ReactNode;
+    error?: ReactNode;
+    invalid?: boolean;
+    className?: string;
+    children: ReactNode;
+}>;
+/** Lay out two fields side by side. */
+declare const FieldRow: FC<{
+    className?: string;
+    children: ReactNode;
+}>;
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    invalid?: boolean;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    invalid?: boolean;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+interface SelectProps extends SelectHTMLAttributes<HTMLSelectElement> {
+    invalid?: boolean;
+}
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLSelectElement>>;
+interface CheckboxProps extends InputHTMLAttributes<HTMLInputElement> {
+    label?: ReactNode;
+}
+/** A checkbox is its own label — don't wrap it in `<Field>`. */
+declare const Checkbox: FC<CheckboxProps>;
+
+/**
+ * Data-driven custom fields. The event describes what to collect
+ * (`EventCustomField[]`, order- / ticket- / add-on-scoped); these render it —
+ * text, textarea, phone, email, select, radio, checkbox, multi-select — and
+ * report values back. No per-brand form code: pass the group, hold the values.
+ *
+ *   const [vals, setVals] = useState<CustomFieldValues>({})
+ *   <CustomFieldGroupFields group={group} values={vals}
+ *     onChange={(name, v) => setVals(s => ({ ...s, [name]: v }))} />
+ */
+
+type FieldValue = string | string[];
+interface CustomFieldInputProps {
+    field: EventCustomField;
+    value: FieldValue | undefined;
+    onChange: (value: FieldValue) => void;
+    error?: ReactNode;
+}
+/** Render one custom field by its declared `type`. */
+declare const CustomFieldInput: FC<CustomFieldInputProps>;
+interface CustomFieldGroupFieldsProps {
+    group: EventCustomFieldGroup;
+    values: CustomFieldValues;
+    onChange: (name: string, value: FieldValue) => void;
+    /** Restrict to fields scoped to this holder's ticket type (ticket groups). */
+    ticketTypeId?: string;
+}
+/** Render every field in a group, wired to a values map. */
+declare const CustomFieldGroupFields: FC<CustomFieldGroupFieldsProps>;
+
+/**
+ * `<PaymentMethods>` — a controlled radio-list of payment methods (icon + label
+ * per row), matching the hosted checkout's iconed selector. Presentational only:
+ * it renders the choices + the selected row's extra input (and hosts a card
+ * field in the card row via `children`/`inputSlotFor`). It does NOT own the Pay
+ * button or `placeOrder` — `<Payment/>` builds the options and maps a selection
+ * back to a `placeOrder` request.
+ */
+
+interface PaymentMethodsProps {
+    options: PaymentMethodOption[];
+    /** Selected `option.value` (controlled). */
+    selected: string;
+    onSelect: (value: string) => void;
+    /** Extra-field values keyed by `option.value`. */
+    extraValues: Record<string, {
+        cashtag?: string;
+        phoneNumber?: string;
+    }>;
+    onExtraChange: (value: string, patch: {
+        cashtag?: string;
+        phoneNumber?: string;
+    }) => void;
+    /** Reveal required extra-field errors after the buyer attempts payment. */
+    showValidation?: boolean;
+    /** Rendered inside the row whose `value === inputSlotFor` (e.g. `<CardInput/>`). */
+    children?: ReactNode;
+    inputSlotFor?: string;
+    className?: string;
+}
+declare const PaymentMethods: FC<PaymentMethodsProps>;
+
+/** Quantity ± control (ticket / add-on quantities). */
+declare const Stepper: FC<{
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+}>;
+
+/**
+ * `<QuantitySelect>` — a compact quantity dropdown (0…max), the control the old
+ * checkout used for tickets and add-ons (not a +/- stepper).
+ */
+
+interface QuantitySelectProps {
+    value: number;
+    onChange: (value: number) => void;
+    /** Minimum purchasable quantity when buying (0 = none is always allowed). */
+    min?: number;
+    max?: number;
+    /** Step between options (the old checkout's `multiplier`). */
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare const QuantitySelect: FC<QuantitySelectProps>;
+
+/** A price with optional struck-through original + a fees/deposit note. */
+declare const PriceLine: FC<{
+    currency?: string;
+    amount: number | string;
+    /** Struck-through pre-discount price. */
+    original?: number | string;
+    /** e.g. "incl. fees" or "50% deposit". */
+    note?: ReactNode;
+    className?: string;
+}>;
+
+/** Reservation countdown. Pass `checkout.secondsLeft`. */
+declare const Timer: FC<{
+    seconds: number;
+    /** Below this many seconds it turns urgent (default 60). */
+    urgentAt?: number;
+    /** Text before the clock, e.g. "Reserved for". */
+    label?: ReactNode;
+    className?: string;
+}>;
+
+/**
+ * `<TimerBanner>` — the reservation countdown banner the old checkout showed at
+ * the top of the add-ons / billing / payment steps: "Please complete your
+ * purchase before the timer reaches zero." + mm:ss, with a dismiss X. Feed it
+ * `checkout.secondsLeft`. Renders nothing when there's no live reservation.
+ */
+
+interface TimerBannerProps {
+    seconds?: number;
+    /** Show red styling at/under this many seconds. Default 60. */
+    urgentAt?: number;
+    message?: string;
+    className?: string;
+}
+declare const TimerBanner: FC<TimerBannerProps>;
+
+/** A spinner that inherits `currentColor` (so it works inside buttons/text). */
+declare const Loader: FC<{
+    className?: string;
+}>;
+
+/**
+ * MSI (meses sin intereses) picker. Mexican card payments can be split into
+ * interest-free installments: mid-payment the engine calls `onInstallmentOffers`
+ * with the available plans and waits for the buyer's choice. This hook bridges
+ * that callback to an overlay — `<CheckoutProvider>` wires it by default, so
+ * `<EmbeddedCheckout/>` gets MSI for free. Returns the port + the overlay to render.
+ */
+
+declare const useInstallmentPicker: () => {
+    onInstallmentOffers: (offers: InstallmentOffer[]) => Promise<InstallmentOffer | null>;
+    picker: React.JSX.Element | null;
+};
+
+interface I18nProviderProps {
+    locale?: LocaleCode;
+    /** Per-key overrides, merged over the locale. */
+    messages?: Partial<Messages>;
+    children?: ReactNode;
+}
+declare const I18nProvider: FC<I18nProviderProps>;
+/** Returns the active translator. Safe to call anywhere in the SDK tree. */
+declare const useT: () => Translate;
+
+interface AuthModalProps {
+    open: boolean;
+    onClose: () => void;
+    initialView?: AuthFlowView;
+    initialEmail?: string;
+    /** Optional context shown above the active form. */
+    message?: string;
+    allowRegistration?: boolean;
+    allowPasswordReset?: boolean;
+    requireRegistrationAddress?: boolean;
+    /** Extra backend fields for specialized registrations such as delegations. */
+    registrationFields?: Record<string, string>;
+    logoUrl?: string;
+    onAuthenticated?: (profile: TfProfile) => void;
+    className?: string;
+}
+/** Accessible web presentation over `hooks.useAuthFlow()`. Render it inside
+ * `<CheckoutProvider>` so it inherits the checkout theme tokens. */
+declare const AuthModal: FC<AuthModalProps>;
+
+interface LoginFormProps {
+    initialEmail?: string;
+    errors?: AuthFieldErrors;
+    error?: string;
+    loading?: boolean;
+    allowPasswordReset?: boolean;
+    onSubmit: (input: AuthLoginInput) => void | Promise<unknown>;
+    onForgotPassword?: (email: string) => void;
+    onFieldChange?: (field: keyof AuthLoginInput) => void;
+}
+/** Pure web form: it renders fields and delegates all auth work to its caller. */
+declare const LoginForm: FC<LoginFormProps>;
+
+interface RegisterFormProps {
+    initialEmail?: string;
+    errors?: AuthFieldErrors;
+    error?: string;
+    loading?: boolean;
+    requireAddress?: boolean;
+    onSubmit: (input: AuthRegistrationInput, options: {
+        requireState: boolean;
+    }) => void | Promise<unknown>;
+    onFieldChange?: (field: AuthFieldName) => void;
+}
+/** Legacy-compatible account fields with no API or validation logic inside. */
+declare const RegisterForm: FC<RegisterFormProps>;
+
+interface ForgotPasswordFormProps {
+    initialEmail?: string;
+    errors?: AuthFieldErrors;
+    error?: string;
+    successMessage?: string;
+    loading?: boolean;
+    onSubmit: (email: string) => void | Promise<unknown>;
+    onBackToLogin: (email: string) => void;
+    onFieldChange?: () => void;
+}
+/** Password-recovery presentation over the shared auth-flow controller. */
+declare const ForgotPasswordForm: FC<ForgotPasswordFormProps>;
+
+interface ResetPasswordFormProps {
+    /** Token from the password-reset email. */
+    token: string;
+    onSuccess?: () => void;
+    onBackToLogin?: () => void;
+}
+/** Complete the password-reset flow started by `<ForgotPasswordForm/>`. */
+declare const ResetPasswordForm: FC<ResetPasswordFormProps>;
+
+/**
+ * `<Tickets/>` — ticket selection. Lists the event's ticket types with a
+ * quantity dropdown, applies promo / access codes (re-pricing + unlocking
+ * tickets), offers a waiting-list sign-up on sold-out types, and primes the
+ * cart. Matches the old checkout: no running total, a `GET TICKETS` CTA.
+ */
+
+interface TicketsProps {
+    eventId: string;
+    /** Optional heading above the catalog. The legacy storefront does not show
+     *  one, so the default is intentionally hidden. */
+    title?: ReactNode | false;
+    /** Fired once the cart is primed (tickets added) — e.g. reveal `<AddOns/>`. */
+    onContinue?: () => void;
+    /** CTA label. Old storefront uses "Get tickets". */
+    buttonLabel?: string;
+    /** Force time-slot mode + supply the selectable session dates (ISO yyyy-mm-dd).
+     *  Omit to auto-detect from the event (`isTimeSlotEvent` / `availableDates`). */
+    timeSlotDates?: string[];
+    /** Optional numbered badge (old checkout shows none — omitted by default). */
+    step?: ReactNode;
+    /** SEATED events: fired when the buyer clicks "Select seats". Wire this to
+     *  reveal `<SeatMap/>`. Without it the seat CTA is hidden (the seat-map ticket
+     *  types then have no way to be bought — provide it for seated events). */
+    onSelectSeats?: () => void;
+    /** Apply this code once when the ticket catalog mounts. */
+    initialPromoCode?: string;
+    /** Attribute this visit once. URL values use `ttf_r` / `referrer_id`. */
+    referrer?: string | number;
+    /** Also read promo/referral values from the current URL. Defaults true. */
+    readAttributionFromUrl?: boolean;
+    className?: string;
+}
+declare const Tickets: FC<TicketsProps>;
+
+/**
+ * `<SeatMap/>` — the venue seat picker for seated events, rebuilt to match the
+ * legacy `seatMapContainer` exactly (the REAL seat wire, not the earlier
+ * inferred mapping):
+ *
+ *  1. Fetch the chart (`seat-map-data`) → `seatData`, `ticketTypeTierRelations`,
+ *     `eventSeats`, `seatReservationTime`, `seatMapType`, `tierPrices`,
+ *     `predefinedSeats`. Poll `seats/status` every 3s and derive the seats this
+ *     buyer owns (status `'OR'`).
+ *  2. Clicking a seat reserves it (`ttf.seatmap.reserve`, one seat per call);
+ *     clicking a held seat releases it (`ttf.seatmap.removeReserved`). Blocked /
+ *     reserved-by-others seats and the 10-seat cap are enforced like legacy.
+ *  3. Each held seat gets a ticket-type dropdown (auto-selected when its tier
+ *     offers only one) and, for table/group types, a guest-count dropdown.
+ *  4. "Get tickets" turns the held seats into `SeatLine`s and calls
+ *     `checkout.setSeats(eventId, lines)` → the seat-aware add-to-cart + price.
+ *
+ * Boundaries (documented, not hidden):
+ *  - `tf-seat-map-view` is an OPTIONAL peer dependency. Install it and import its
+ *    CSS (`import 'tf-seat-map-view/dist/index.css'`) to use this section; it is
+ *    lazy-loaded + externalized, so it never weighs on the base SDK.
+ *  - Guest-count → cart shape follows the spec's model: a `SeatLine` carries
+ *    `guests` ONLY for guest-capable (table) types, so plain seated events post
+ *    aggregated per-type quantities and table events post one indexed line per
+ *    seat with `quantity = guests`. Validate against a real table-map event.
+ */
+
+interface SeatMapProps {
+    eventId: string;
+    /** Fired once seats are added to the cart + priced — e.g. reveal billing. */
+    onContinue?: () => void;
+    /** Badge content. Defaults to a seat glyph. */
+    step?: ReactNode;
+    className?: string;
+}
+declare const SeatMap: FC<SeatMapProps>;
+
+/**
+ * `<AddOns/>` — optional upsells for the primed cart. Lists the event's add-ons
+ * (filtered to the tickets in the cart), lets the buyer pick quantities, and
+ * captures any per-add-on custom fields. On continue it writes the selection
+ * (`setAddons`, which reprices) and the captured fields (`setAddonDataCapture`).
+ *
+ * Renders nothing when the event has no applicable add-ons, so it's safe to
+ * always place between `<Tickets/>` and `<BillingInfo/>`.
+ */
+
+interface AddOnsProps {
+    eventId: string;
+    /** Fired once add-ons are saved to the cart — e.g. reveal `<BillingInfo/>`. */
+    onContinue?: () => void;
+    /** Fired when the buyer skips add-ons. Hidden when a required add-on exists. */
+    onSkip?: () => void;
+    /** CTA label. Old checkout uses "CONFIRM SELECTION". */
+    buttonLabel?: string;
+    /** Eyebrow above the title. Old checkout uses "Get Your Tickets". */
+    eyebrow?: string;
+    /** Section heading. Old checkout uses "UPGRADES & ADD-ONS". */
+    heading?: string;
+    className?: string;
+}
+declare const AddOns: FC<AddOnsProps>;
+
+/**
+ * `<BillingInfo/>` — the buyer + attendee details step. Collects: the buyer's
+ * name/email + event-gated buyer fields (Instagram/nationality/gender), any
+ * ORDER-level custom fields, PER-HOLDER name + ticket-level custom fields (when
+ * the event requires holder names or has ticket-scoped fields), and marketing
+ * opt-ins. Writes it all into the engine (`setBilling` with `dataCapture`,
+ * `setHolders` with `ticketDataCapture`, `setConsent`) so `<Payment/>`'s
+ * pre-flight passes. Use it alongside `<Payment/>`, or set those yourself.
+ */
+
+interface BillingInfoProps {
+    /** Event context is used to default the country and phone dial code. */
+    eventId?: string;
+    /** Fired once billing is saved to the engine — e.g. reveal `<Payment/>`. */
+    onContinue?: () => void;
+    /** Section heading. Old checkout uses "Billing Information". */
+    heading?: string;
+    /** CTA label. */
+    buttonLabel?: string;
+    /** When provided and the buyer isn't signed in, shows a "Login & skip ahead"
+     *  row. The current email is passed when login follows an account match. */
+    onLogin?: (email?: string) => void;
+    /** Hide this card only after a signed-in profile satisfies every ordinary
+     *  billing requirement and the event needs no extra buyer/holder answers. */
+    skipWhenProfileComplete?: boolean;
+    /** Ask guests to repeat their email and require an exact match. */
+    requireEmailConfirmation?: boolean;
+    /** Always collect one named holder per selected ticket. EmbeddedCheckout uses
+     *  this to match tf-sports; standalone sections default to backend gates. */
+    collectTicketHolders?: boolean;
+    /** When holder details are enabled, also collect each holder's email and phone. */
+    collectHolderContact?: boolean;
+    /** Marketing opt-in labels. Render a checkbox for each provided (unchecked). */
+    ttfOptInLabel?: string;
+    brandOptInLabel?: string;
+    /** Required host privacy acknowledgement. The URL is supplied by the consumer. */
+    privacyPolicy?: CheckoutPrivacyPolicy;
+    /** Show the legacy inline "Required" error after a failed payment attempt. */
+    showPrivacyError?: boolean;
+    /** Optional numbered badge (old checkout shows none — omitted by default). */
+    step?: ReactNode;
+    className?: string;
+}
+interface CheckoutPrivacyPolicy {
+    url: string;
+    brandName: string;
+    linkLabel?: string;
+}
+declare const BillingInfo: FC<BillingInfoProps>;
+
+/**
+ * `<Payment/>` — order review + payment-method selection + T&C, then place the
+ * order. Buyer details come from `<BillingInfo/>` (read back off the shared
+ * checkout). The method list is built from the event's gateway + `preOrderMethods()`
+ * + the priced snapshot, and each selection maps to the right `placeOrder` rail
+ * (Stripe card, Xendit card/e-wallet, PayPal, redirect rails, payment plan).
+ */
+
+interface PaymentProps {
+    onComplete?: (order: PlaceOrderResult) => void;
+    /** Optional event context adds the event name to the order review. */
+    eventId?: string;
+    /** Must match the policy used by the paired `<BillingInfo/>`. */
+    requireEmailConfirmation?: boolean;
+    /** Must match the holder policy used by the paired `<BillingInfo/>`. */
+    collectTicketHolders?: boolean;
+    /** Must match the holder-contact policy used by the paired `<BillingInfo/>`. */
+    requireHolderContact?: boolean;
+    /** Host-owned acknowledgements such as a brand privacy policy. */
+    additionalConditions?: EventCondition[];
+    /** Require the privacy checkbox managed by BillingInfo before payment. */
+    requirePrivacyPolicy?: boolean;
+    /** Called when payment is attempted before required privacy consent. */
+    onPrivacyRequired?: () => void;
+    /** Test card copy is useful in examples, but should never appear by default. */
+    showTestCardHint?: boolean;
+    className?: string;
+}
+declare const Payment: FC<PaymentProps>;
+
+interface OrderSummaryProps {
+    eventId?: string;
+    className?: string;
+}
+/** Storefront-compatible order summary shown after the checkout controls. */
+declare const OrderSummary: FC<OrderSummaryProps>;
+
+/**
+ * `<IDVerification/>` — shown after an order that needs identity verification
+ * (`order.needIdVerification`). Kicks off the engine's verify flow: mint the
+ * provider URL, open it, and poll to completion, reflecting each phase. The
+ * order is already paid — a stall here never means a failed payment.
+ *
+ * If you place your order with `placeOrder(method, { autoRunIdVerification:true })`
+ * the engine runs this for you; this section is the manual, visible counterpart.
+ */
+
+interface IDVerificationProps {
+    className?: string;
+}
+declare const IDVerification: FC<IDVerificationProps>;
+
+/**
+ * `<Confirmation/>` — the order-placed receipt + a referral/share growth block
+ * (invite friends → cheaper/free tickets). Reads the settled order off the
+ * shared checkout; returns null until an order exists.
+ *
+ * Fire purchase tracking (Meta Pixel / GTM) from the `onComplete(order)` callback
+ * you already pass to `<Payment/>` / `<EmbeddedCheckout/>` — the SDK stays analytics-
+ * agnostic. The referral REWARD ladder ("how much cheaper") needs the order
+ * confirmation payload, which is left to the consumer (pass `children`); the
+ * share affordances below need no backend data.
+ */
+
+interface ConfirmationProps {
+    /** URL friends land on (referral/event page). Defaults to the current page. */
+    shareUrl?: string;
+    /** Message prefilled into social shares. */
+    shareMessage?: string;
+    /** Link to the buyer's tickets/order — renders a "View my tickets" button. */
+    viewOrderUrl?: string;
+    /** Extra content (e.g. your own referral-reward ladder from the order payload). */
+    children?: ReactNode;
+    className?: string;
+}
+declare const Confirmation: FC<ConfirmationProps>;
+
+type ConfirmationData = Record<string, any>;
+interface OrderConfirmationProps {
+    orderHash: string;
+    title?: ReactNode;
+    message?: ReactNode;
+    helper?: ReactNode;
+    eventTitle?: ReactNode;
+    eventDate?: ReactNode;
+    eventLocation?: ReactNode;
+    viewOrderUrl?: string | ((data: ConfirmationData) => string);
+    showReferral?: boolean;
+    showShareButtons?: boolean;
+    onLoaded?: (data: ConfirmationData) => void;
+    onError?: (error: unknown) => void;
+    className?: string;
+}
+/**
+ * Reloadable post-purchase confirmation. Its markup intentionally preserves
+ * the proven legacy checkout class contract so existing white-label themes do
+ * not lose their confirmation-page UX when they adopt Checkout Kit.
+ */
+declare const OrderConfirmation: FC<OrderConfirmationProps>;
+
+interface OrderIDVerificationProps {
+    orderHash: string;
+    onVerified?: () => void;
+    className?: string;
+}
+/** Routed ID-verification UI that survives a full page navigation. */
+declare const OrderIDVerification: FC<OrderIDVerificationProps>;
+
+/**
+ * `<EmbeddedCheckout eventId="…" />` — the batteries-included checkout. It
+ * follows the legacy storefront UX: ticket selection and checkout are separate
+ * views, with a compact selection summary + Edit action once the cart is
+ * reserved. Want a different layout? Compose the sections yourself — they all
+ * read the same `useCheckout()` from the provider.
+ */
+
+interface EmbeddedCheckoutProps {
+    /** The event whose tickets to sell. */
+    eventId: string;
+    /** Called with the placed order once payment settles. */
+    onComplete?: (order: PlaceOrderResult) => void;
+    /**
+     * `inline` renders verification/confirmation inside the checkout. `redirect`
+     * leaves completion routing to `onComplete` and shows a short transition
+     * state while the host navigates. Defaults to `inline`.
+     */
+    confirmationMode?: 'inline' | 'redirect';
+    /** Initial checkout screen. Useful for preserving an existing `/seat-map` route. */
+    initialView?: 'tickets' | 'seats';
+    /** Reports the visible flow view so host storefronts can coordinate mobile UI. */
+    onViewChange?: (view: CheckoutView) => void;
+    /** Smooth-scroll to buyer details after tickets/seats are reserved. Default true. */
+    autoScroll?: boolean;
+    /** Require guests to repeat their email. Defaults to storefront-compatible true. */
+    requireEmailConfirmation?: boolean;
+    /** Collect one named holder per ticket. Defaults true to match tf-sports. */
+    collectTicketHolders?: boolean;
+    /** Collect email/phone when ticket-holder details are required. Defaults true. */
+    collectHolderContact?: boolean;
+    /** Open the host application's login UI instead of the built-in modal. The
+     *  current buyer email is passed when an existing account was detected. */
+    onLogin?: (email?: string) => void;
+    /** Configure the built-in login/create-account/password-reset modal, or set
+     *  false to remove auth UI. Ignored when `onLogin` is provided. */
+    auth?: false | EmbeddedCheckoutAuthOptions;
+    /** Legacy skip-billing equivalent for complete signed-in profiles. Payment is
+     *  never skipped. Defaults false; incompatible holder/custom fields prevent it. */
+    skipBillingWhenProfileComplete?: boolean;
+    /** Optional marketing copy controlled by the embedding brand. */
+    ttfOptInLabel?: string;
+    brandOptInLabel?: string;
+    /** Consumer-owned privacy policy link and brand name. Required when provided. */
+    privacyPolicy?: CheckoutPrivacyPolicy;
+    /** Host-owned required/optional acknowledgements, e.g. a privacy policy. */
+    additionalConditions?: EventCondition[];
+    /** Apply/attribute hosted links without requiring a custom Tickets section. */
+    initialPromoCode?: string;
+    referrer?: string | number;
+    readAttributionFromUrl?: boolean;
+    /** Opt into sandbox card copy in demos. Defaults false. */
+    showTestCardHint?: boolean;
+    /** Recolor via design tokens. */
+    theme?: CheckoutTheme;
+    /**
+     * Language for the checkout's own copy. Defaults to `en-GB`, so existing
+     * consumers that never set it render exactly as before.
+     */
+    locale?: LocaleCode;
+    /** Per-key copy overrides, merged over the locale. */
+    messages?: Partial<Messages>;
+    className?: string;
+}
+interface EmbeddedCheckoutAuthOptions {
+    allowRegistration?: boolean;
+    allowPasswordReset?: boolean;
+    requireRegistrationAddress?: boolean;
+    logoUrl?: string;
+    onAuthenticated?: (profile: TfProfile) => void;
+}
+type SelectionView = 'tickets' | 'seats';
+type CheckoutView = SelectionView | 'checkout';
+declare const EmbeddedCheckout: FC<EmbeddedCheckoutProps>;
+
+interface ResumedCheckoutProps {
+    eventId: string;
+    isFromResale?: boolean;
+    onComplete?: (order: PlaceOrderResult) => void;
+    confirmationMode?: 'inline' | 'redirect';
+    requireEmailConfirmation?: boolean;
+    collectTicketHolders?: boolean;
+    collectHolderContact?: boolean;
+    privacyPolicy?: CheckoutPrivacyPolicy;
+    brandOptInLabel?: string;
+    additionalConditions?: EventCondition[];
+    theme?: CheckoutTheme;
+    className?: string;
+}
+/** Checkout UI for a cart created by a preceding server flow, such as resale. */
+declare const ResumedCheckout: FC<ResumedCheckoutProps>;
+
+/** Raw card field values, read at tokenize time (never held in JS state). */
+interface XenditCardFields {
+    number: string;
+    /** "MM" */
+    expMonth: string;
+    /** "YY" or "YYYY" — 2-digit is expanded to 20YY. */
+    expYear: string;
+    cvn: string;
+}
+interface WebXenditTokenizer {
+    /** `<XenditCardInput/>` registers a getter for its live field values (or
+     *  null on unmount). */
+    registerFields(getFields: (() => XenditCardFields) | null): void;
+    /** Tokenizes the registered card (running inline 3DS when the bank asks) and
+     *  resolves with the token the engine charges. Rejects on validation error,
+     *  decline, or a failed 3DS challenge. */
+    tokenize(params: {
+        publishableKey: string;
+        amount: string | number;
+        billing: {
+            firstName: string;
+            lastName: string;
+            email: string;
+            phone?: string;
+        };
+        onBehalfOf?: string | null;
+    }): Promise<Record<string, unknown>>;
+}
+declare const createWebXenditTokenizer: () => WebXenditTokenizer;
+
+/**
+ * Web (stripe-js) adapter of the SDK's PaymentConfirmer port — the proof that
+ * the engine in `tf-checkout-shared` is genuinely platform-free. Bind it via
+ * `useCheckout({ ports: { confirmer: webConfirmer, ...webPorts } })` to run the
+ * exact same cart → order → charge → finalize sequence React Native runs (same
+ * retry-safety invariants, same duplicate-charge guards, same tests).
+ *
+ * Card payments on the web confirm against a Stripe Element the consumer
+ * renders: register it via `confirmer.registerCardElement(element)` before
+ * placing the order. Apple Pay is not bound on web yet (the web equivalent is
+ * the Payment Request button, a different integration) — `confirmApplePay`
+ * throws with a clear message.
+ */
+
+interface WebStripeConfirmer extends PaymentConfirmer {
+    /** The card Element the consumer rendered — required before confirmCard. */
+    registerCardElement(element: StripeCardElement | null): void;
+    /** The currently registered card Element (null before registration) —
+     *  the MSI port creates its PaymentMethod from it. */
+    getCardElement(): StripeCardElement | null;
+    /**
+     * The Elements GROUP backing a `<StripePaymentElement/>` (deferred mode).
+     * This is how the old checkout did wallets: when a Payment Element is
+     * registered, `confirmCard` confirms card + Apple Pay + Google Pay through it
+     * (`elements.submit()` + `stripe.confirmPayment`), exactly as the old
+     * `useStripePayment.processPayment` did. Null when only a bare card is rendered.
+     */
+    registerPaymentElement(elements: StripeElements | null): void;
+    getPaymentElement(): StripeElements | null;
+    /**
+     * The live Stripe instance (null before the flow calls init). Elements MUST
+     * be created from this instance — stripe-js rejects confirming with an
+     * Element born from a different one:
+     * `confirmer.getStripe()!.elements().create('card')`.
+     */
+    getStripe(): Stripe | null;
+    /** Resolves with the Stripe instance as soon as init() has run — mount UI
+     *  against this instead of polling getStripe(). */
+    whenReady(): Promise<Stripe>;
+}
+declare const createWebStripeConfirmer: () => WebStripeConfirmer;
+/**
+ * The web half of the engine's `CheckoutPorts`:
+ *
+ * - `providerPage` runs the provider in a POPUP and resolves when navigation
+ *   lands back on `returnUrlPrefix` (same-origin, so the URL is readable);
+ *   a closed popup resolves as 'dismiss'. Call `placeOrder` from a click
+ *   handler, or the browser's popup blocker will refuse the window.
+ * - `confirmOxxo` / `createCardPaymentMethod` / `createRedirectPaymentMethod`
+ *   / `handleNextAction` bind the same Stripe legs the RN ports bind.
+ *
+ * MSI's `onInstallmentOffers` picker stays consumer-supplied (pass it via
+ * `placeOrder(request, ports)`).
+ */
+declare const createWebPorts: (confirmer: WebStripeConfirmer, 
+/** The Xendit card tokenizer `<XenditCardInput/>` binds to. When given, the
+ *  engine tokenizes Xendit cards inline instead of in a popup. */
+xenditTokenizer?: WebXenditTokenizer) => Omit<CheckoutPorts, "confirmer">;
+
+/** The confirmer every `useCheckout`/`<CardInput/>` binds to. */
+declare const webConfirmer: WebStripeConfirmer;
+/** The Xendit card tokenizer `<XenditCardInput/>` binds to. */
+declare const webXenditTokenizer: WebXenditTokenizer;
+/** The web ports the alternative rails run on: the popup provider page, OXXO /
+ *  MSI Stripe legs, and inline Xendit tokenization. */
+declare const webPorts: Omit<CheckoutPorts, "confirmer">;
+
+export { ADD_ON_DEFAULT_MAX_QUANTITY, AddOns, type AddOnsProps, type AddonSelection, type AuthFieldErrors, type AuthFieldName, type AuthFlowView, type AuthLoginInput, AuthModal, type AuthModalProps, type AuthProvider, type AuthRegistrationInput, type AuthValidationResult, type BillingDraft, type BillingFieldError, BillingInfo, type BillingInfoProps, type BreakdownLine, Button, type ButtonProps, type BuyerFieldSpec, type BuyerFieldVisibility, type BuyerFieldsInput, CONFIRMED_INTENT_STATUSES, Card, CardInput, type CardProps, type ChangePaymentMethodInput, Checkbox, type CheckboxProps, type CheckoutBilling, type CheckoutBreakdown, type CheckoutConsent, type CheckoutDetailsState, type CheckoutDetailsValidationOptions, type CheckoutEngine, type CheckoutHolder, type CheckoutListener, type CheckoutOptions, type CheckoutPaymentPlan, type CheckoutPaymentPlanPreview, type CheckoutPorts, type CheckoutPrivacyPolicy, CheckoutProvider, type CheckoutProviderProps, type CheckoutSnapshot, type CheckoutStatus, type CheckoutStore, type CheckoutTheme, type CheckoutWalletAvailability, Confirmation, type ConfirmationProps, type ContactEmailResponse, type CurrencyOption, type CurrencyState, type CurrencySync, type CurrencySyncOptions, type CurrencyTransport, CustomFieldGroupFields, type CustomFieldGroupFieldsProps, CustomFieldInput, type CustomFieldInputProps, type CustomFieldOption, type CustomFieldType, type CustomFieldValues, DEFAULT_LOCALE, DEFAULT_PLAN_TERMINOLOGY, ENDPOINTS, EmbeddedCheckout, type EmbeddedCheckoutAuthOptions, type EmbeddedCheckoutProps, type Endpoints, type EngineConfig, type EngineContext, type EventAddon, type EventCondition, type EventCustomField, type EventCustomFieldGroup, type ExistingAccount, FEE_MODE_PAYMENT_METHOD_TYPES, Field, type FieldGates, FieldRow, ForgotPasswordForm, type ForgotPasswordFormProps, type Gateway, type HolderDraft, I18nProvider, type I18nProviderProps, IDVerification, type IDVerificationProps, ID_VERIFICATION_MAX_CONSECUTIVE_FAILURES, ID_VERIFICATION_MAX_TICKS, ID_VERIFICATION_POLL_MS, type IdVerificationCallbacks, type IdVerificationPhase, type IdVerificationPoller, type IdVerificationStatus, Input, type InputProps, type InstallmentOffer, type InstallmentOffers, Loader, type LocaleCode, type LocationOption, LoginForm, type LoginFormProps, type Messages, type OnCheckoutAttributes, type OnCheckoutInput, OrderConfirmation, type OrderConfirmationProps, OrderIDVerification, type OrderIDVerificationProps, type OrderPaymentSession, type OrderProgress, OrderSummary, type OrderSummaryProps, type OxxoVoucher, type PayPalForm, type PayPalTabConfig, Payment, type PaymentConfirmer, type PaymentConfirmerExtras, type PaymentMethod, type PaymentMethodId, type PaymentMethodOption, type PaymentMethodTypeInput, type PaymentMethodTypeRequest, PaymentMethods, type PaymentMethodsProps, type PaymentProps, type PaymentRequest, Pill, type PlaceOrderHookOptions, type PlaceOrderResult, type PlanTermsParagraph, type PreOrderGateway, type PreOrderPaymentConfig, type PriceBreakdown, type PriceBreakdownAddOnRow, type PriceBreakdownFeeRow, type PriceBreakdownTicketRow, PriceLine, type ProviderPageOutcome, type ProviderPageRequest, QuantitySelect, type QuantitySelectProps, type RazorpayCheckoutHtmlOptions, type RedirectConfirmRequest, type RedirectConfirmResponse, type RedirectOutcome, RegisterForm, type RegisterFormProps, type RequiredAddOnLike, ResetPasswordForm, type ResetPasswordFormProps, type ResolvedTtfConfig, ResumedCheckout, type ResumedCheckoutProps, type RunIdVerificationOptions, SUPPORTED_REDIRECT_METHODS, type SavedPlanCard, type SeatLine, SeatMap, type SeatMapProps, SectionHeader, type SectionHeaderProps, Select, type SelectProps, Stepper, type StorageAdapter, type StripeConfig, StripePaymentElement, type StripeWallets, Textarea, type TextareaProps, type TfCountry, type TfEnvelope, type TfListEnvelope, type TfProfile, type TfState, type TfTicketHolder, type TicketHolderInput, type TicketSelection, type TicketType, Tickets, type TicketsProps, Timer, TimerBanner, type TimerBannerProps, type Translate, type TranslateVars, type TranslatorOptions, type Ttf, type TtfConfig, TtfError, type UseCheckout, type UseCheckoutOptions, type WaitingListEntry, type WalletsOption, type WebStripeConfirmer, type WebXenditTokenizer, XENDIT_EWALLET_EXTRA_FIELD, XENDIT_NON_EWALLET_PROCESSORS, type XenditCardFields, XenditCardInput, type XenditChargeOutcome, type XenditCheckoutHtmlOptions, type XenditEWalletChargeInput, type XenditPreOrderConfig, type XenditProcessor, addOnMaxQuantity, index$1 as api, buildAutoSubmitFormHtml, buildChangePaymentMethodAttributes, buildConfirmInstallmentsFields, buildInstallmentOffersFields, buildOnCheckoutBody, buildPaymentMethodTypeAttributes, buildRazorpayCheckoutHtml, buildRegistrationFields, buildXenditCheckoutHtml, buildXenditEWalletChargeFields, cleanAccountId, clearSession, configure, configureCheckout, confirmInstallmentsHasNextAction, createCheckoutStore, createEngine, createIdVerificationPoller, createIdVerificationPollerFor, createMemoryStorage, createTranslator, createWebPorts, createWebStripeConfirmer, createWebXenditTokenizer, customFieldsComplete, cx, detectGateway, en, errorMessage, esMX, evaluateFieldGates, fieldAppliesToTicketType, formatPlanMoney, getAccessToken, getGuestToken, hasValue, index as hooks, identifyPreOrderGateway, initialSnapshot, interpretContactEmail, interpretRedirectConfirm, interpretXenditChargeResponse, isAuthenticated, isCartExpiredError, isConfigured, isEmail, isMultiCurrency, isPhone, isSeatedEvent, listRedirectMethods, localStorageAdapter, mapProfileToBilling, missingCheckoutDetails, missingRequiredAddOns, normalizeAuthEmail, oxxoVoucherFromNextAction, payOrderWith, paymentIntentIdFromClientSecret, paymentPlanTerms, paypalTabConfig, placeOrderWith, planCheckboxLabel, planConfirmLabel, planTerminology, planTermsTitle, priceBreakdownAddOnsQuery, primeSeatsWith, primeWith, registerCatalogue, repriceWith, requiresFeeReprice, resolveInstallmentOffers, resolveLocale, resolvePayPalForm, resolvePaymentConfig, resolvePriceBreakdown, resumeCartWith, runIdVerificationWith, savedPlanCard, syncCurrency, syncCurrencyWith, themeToVars, ticketFieldsFor, ticketQuantityRange, ttf, unsupportedGatewayError, useCheckout, useCheckoutContext, useCheckoutValidation, useInstallmentPicker, useT, validateLoginInput, validatePasswordResetEmail, validateRegistrationInput, walletsOption, webConfirmer, webPorts, webXenditTokenizer, xenditPreOrderConfig };