@seatlayer/js 0.71.2 → 0.71.3

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { PickerSeat, PickerGAArea, PickerSelectionValidator, PickerMapTheme, RendererViewMode, SeatHoverDetails, PickerSelectionValidity, SectionSummary, ChartTheme, LodRung, PickerTransport, PickerController, AccessibilityType, ExpandedSeat } from '@seatlayer/core';
+import { PickerSeat, PickerGAArea, PickerMapTheme, PickerTransport, PickerSelectionValidator, RendererViewMode, PickerSelectionValidity, SeatHoverDetails, SectionSummary, ChartTheme, LodRung, PickerController, AccessibilityType, ExpandedSeat } from '@seatlayer/core';
 export { ExpandedSeat, PickerMapTheme, PickerSelectionValidator, PickerSelectionValidity, PickerSelectionViolation, RendererViewMode, SeatHoverDetails } from '@seatlayer/core';
-import * as _seatlayer_core_core_seatConfidence from '@seatlayer/core/core/seatConfidence';
-import { Venue3DHandle } from '@seatlayer/core/view3d';
 import { T as ThemeMode } from './channelsMode-goczEzyt.js';
 export { A as AccessIntentForbidsDetails, a as AccessLinkRecord, b as AccessLinkReveal, c as AccessLinkState, d as AccessLinkStatus, e as AccessLinkStatusRecord, f as ArchiveBlockedDetails, g as AssignmentBuckets, h as AssignmentDropDetails, i as AssignmentResult, B as BucketRow, C as ChannelAccessIntent, j as ChannelAccessSummary, k as ChannelAllocationPage, l as ChannelAttribution, m as ChannelAuditEntry, n as ChannelAuditPage, o as ChannelCounts, p as ChannelListResult, q as ChannelPreviewProjection, r as ChannelRecord, s as ChannelReport, t as ChannelReportLinkRecord, u as ChannelReportLinkReveal, v as ChannelReportResult, w as ChannelReportRow, x as ChannelSeatStatus, y as ChannelState, z as ChannelsCapabilities, D as ChannelsClient, E as ChannelsMode, F as ChannelsModeHost, G as ChannelsRowView, H as ChannelsSeatView, I as ControlRoomActivityEntry, J as ControlRoomSectionMetric, K as ControlRoomSnapshot, L as EventCategoryAssignmentResult, M as EventScopedManageToken, N as EventTableBookingMode, O as EventTableBookingResult, P as IntentSwitchBlockedDetails, Q as InventoryBooking, R as InventoryBookingActivity, S as InventoryBookingDetail, U as InventoryBookingObject, V as InventoryBookingState, W as InventoryBookingsPage, X as InventoryBookingsQuery, Y as LogEntry, Z as LogPage, _ as ManageApi, $ as ManageApiError, a0 as ReportByStatus, a1 as ReportCategoryMeta, a2 as ReportCategoryRow, a3 as ReportResult, a4 as SeatManager, a5 as SeatManagerActionResult, a6 as SeatManagerActivity, a7 as SeatManagerCapability, a8 as SeatManagerConnection, a9 as SeatManagerFilteredSection, aa as SeatManagerMode, ab as SeatManagerOptions, ac as SeatManagerSelectionValidity, ad as SeatManagerTallies, ae as SelectionSourceRow } from './channelsMode-goczEzyt.js';
+import * as _seatlayer_core_core_seatConfidence from '@seatlayer/core/core/seatConfidence';
+import { Venue3DHandle } from '@seatlayer/core/view3d';
 
 /**
  * Buyer access context — the browser half of the Sales Channels contract
@@ -622,168 +622,299 @@ type SeatingChartBuyerView = 'map' | 'venue3d';
 type SeatingChartNavigationMode = 'orbit' | 'pan';
 
 /**
- * SeatingChart — the embeddable buyer picker.
+ * Buyer-safe ticket-offer availability shared by the canonical picker and the
+ * hosted event-page templates.
  *
- * A thin wrapper over the shared PickerController (src/picker/PickerController):
- * it owns the mount <div> + the public embed contract (hold-only — the SDK hands
- * the holdId to the host page for a server-side book) and delegates all transport
- * + booking to the controller, so the SDK inherits every fix made for the live
- * buyer page and the demo picker.
+ * This module intentionally owns the wire parser. A hosted page, iframe, popup
+ * and SDK mount must refuse or accept the same payload; duplicating this reader
+ * is how one surface eventually prints a price another surface will not charge.
  */
-
-/** A seat as surfaced to the host page (prices resolved from the chart's categories). */
-type SelectedSeat = PickerSeat;
-interface GAAreaAvailability {
-    id: string;
-    label: string;
-    capacity: number;
-    available: number;
+type SaleState = 'on-sale' | 'low' | 'sold-out' | 'presale' | 'closed';
+interface TicketOfferSummary {
+    /** Legacy ordering fields kept for older page templates and payloads. */
+    index: number;
+    count: number;
+    /** Units currently available at this offer price; null means unlimited. */
+    remaining: number | null;
+    /** Buyer-facing fields added by the offers UX. Absent on older workers. */
+    id?: string;
+    name?: string;
+    categoryKey?: string | null;
+    startsAt?: number | null;
+    endsAt?: number | null;
+}
+interface TicketOfferPrice {
     categoryKey: string;
+    /** Major units. What a hold on this category is charged right now. */
     price: number;
-    currency: string;
-    /** Buyer-facing copy authored separately from stable inventory identity. */
-    displayLabel?: string;
-    displayType?: string;
-    tiers?: Array<{
-        id: string;
-        name: string;
-        price: number;
+    /** Major units, or null. Printed only when genuinely higher. */
+    previousPrice: number | null;
+    /** Offer provenance for the price row. Absent on older workers. */
+    offerId?: string;
+    offerName?: string;
+    remaining?: number | null;
+    startsAt?: number | null;
+    endsAt?: number | null;
+}
+interface ChannelPriceOverride {
+    categoryKey: string;
+    tierId: string | null;
+    price: number;
+}
+/** Pricing configuration projected only for the private channels in this grant. */
+interface BuyerChannelPricing {
+    assignmentVersion: number;
+    channels: Array<{
+        channelId: string;
+        pricingVersion: number;
+        priceOverrides: ChannelPriceOverride[];
+    }>;
+    objects: Array<{
+        label: string;
+        channelId: string;
     }>;
 }
+interface TicketOfferAvailability {
+    state: SaleState;
+    /** Currently advertised offer price, in minor units. */
+    fromPrice: number | null;
+    previousPrice: number | null;
+    currency: string | null;
+    /** The highest-priority active buy offer, when one exists. */
+    release: TicketOfferSummary | null;
+    /** The next scheduled price offer. It does not close ordinary ticket sales. */
+    upcoming: TicketOfferSummary | null;
+    /** Server-resolved active offer prices by category, in major units. */
+    prices: TicketOfferPrice[];
+    channelPricing: BuyerChannelPricing | null;
+}
+/** Parse a public offer payload without repairing a half-understood price. */
+declare function parseTicketOfferAvailability(body: unknown): TicketOfferAvailability | null;
+/** Translate the server-resolved category map into SeatPicker pricing. */
+declare function ticketOfferPrices(availability: TicketOfferAvailability | null): Record<string, number>;
+
 /**
- * Serializable state exposed to hosted native picker chrome. It deliberately
- * contains buyer-display data only: never API keys, buyer-access bearers,
- * provider callbacks, or the active hold id.
+ * pickerTypes — the SeatPicker public option/theme/pricing contract, plus the
+ * two internal shapes (`SectionLike`, `PriceBand`) the picker reads off a
+ * ChartDoc.
+ *
+ * Split out of SeatPicker.ts verbatim; these declarations are the widget's
+ * published API surface, so SeatPicker.ts re-exports every public name from
+ * here and `@seatlayer/js`'s entry (src/index.ts) is untouched. Types only —
+ * nothing in this file emits a byte of runtime JavaScript.
  */
-interface SeatingChartPickerState {
-    event: {
-        key: string;
-        name: string;
-        venue: string | null;
-        startsAt: number | null;
-        timezone: string | null;
-        currency: string;
-        locale: string | null;
-        posterUrl: string | null;
-        mode: 'live' | 'test';
-        salesClosed: boolean;
-    };
-    branding: {
-        accent?: ChartTheme['accent'];
-        accentInk?: ChartTheme['accentInk'];
-        background?: ChartTheme['background'];
-        textColor?: ChartTheme['textColor'];
-        brandName?: ChartTheme['brandName'];
-        logoUrl?: ChartTheme['logoUrl'];
-        /** Native must render SeatLayer attribution when it owns chrome and this is true. */
-        attributionRequired: boolean;
-    };
-    features: {
-        ga: boolean;
-        tiers: boolean;
-        floors: boolean;
-        zones: boolean;
-        sections: boolean;
-        bestAvailable: boolean;
-        accessibilityFilter: boolean;
-        limitedViewFilter: boolean;
-        /** Real lazy-loaded WebGL venue view, not the retired isometric projection. */
-        venue3d: boolean;
-        /** Authored or chart-derived view-from-seat panorama. */
-        seatView: boolean;
-    };
-    catalog: {
-        categories: Array<{
-            key: string;
-            label: string;
-            color: string;
-            price: number;
-            available: number;
-            tiers: Array<{
-                id: string;
-                name: string;
-                price: number;
-                currency?: string;
-            }>;
-        }>;
-        zones: Array<{
-            id: string;
-            label: string;
-            color?: string;
-        }>;
-        sections: Array<{
-            id: string;
-            label: string;
-            displayLabel?: string;
-            zoneId?: string;
-        }>;
-        gaAreas: GAAreaAvailability[];
-        bestAvailableZones: Array<{
-            id: string;
-            label: string;
-        }>;
-    };
-    map: {
-        floors: Array<{
-            id: string;
-            name: string;
-        }>;
-        activeFloorId: string | null;
-        rung: LodRung;
-        focusedSectionId: string | null;
-        focusedSection: SectionSummary | null;
-        viewMode: RendererViewMode;
-        buyerView: SeatingChartBuyerView;
-        view3dTargetSeatId: string | null;
-        view3dNavigationMode: SeatingChartNavigationMode;
-        colorblindSafe: boolean;
-        categoryFilter: string[] | null;
-        accessibilityFilter: string[] | null;
-        hideLimitedView: boolean;
-    };
-    selection: {
-        seats: SelectedSeat[];
-        validity: PickerSelectionValidity | null;
-        maxSelection: number;
-    };
-    access: {
-        configured: boolean;
-        status: 'public' | 'ready' | 'expired' | 'unavailable';
-        reason?: string;
-    };
-}
-interface SeatingChartOptions {
-    /** CSS selector or an HTMLElement to render into. */
-    container: string | HTMLElement;
-    /** Event key, e.g. `ev_xxx`. */
-    event: string;
-    /** API origin. Defaults to https://api.seatlayer.io. */
-    apiBase?: string;
+
+/**
+ * Stable checkout-handoff contract (P4). Passed as the THIRD argument to
+ * `onCheckout(hold, seats, handoff)` — additive, so the legacy `(hold, seats)`
+ * shape used by DesiPass web-v2 (SDK 0.7.3+) is untouched. This is the object to
+ * build your order against: it is self-contained (holdId, expiry, currency, and
+ * per-line tier + price) and never changes shape across minor releases.
+ */
+interface CheckoutLineItem {
+    /** Seat label (or GA synthetic-unit label) — the stable booking identity. */
+    label: string;
     /**
-     * Publishable account key for direct Public-sale bootstrap of a Platform/SDK
-     * Event. It is never buyer identity and cannot request private inventory.
-     * An explicit buyer-access provider/token below always takes precedence.
+     * Buyer-facing name (the designer's `displayLabel` override), when set.
+     * Show this in YOUR order summary; `label` stays the booking identity you
+     * pass to the book call. Absent = no override, fall back to `label`.
      */
-    publicKey?: string;
+    displayLabel?: string;
     /**
-     * Buyer access session provider — the recommended way to render private
-     * channel inventory (Sales Channels guide §6).
-     *
-     * Called with a `reason` whenever the SDK needs a bearer: first acquisition,
-     * a near/actual expiry, a 401 `buyer_access_expired`, a realtime reconnect,
-     * or `refreshAccess()`. It should POST to YOUR backend, which mints the
-     * session with your secret key and returns `{ token, expiresAt }`.
+     * Buyer-facing type word override (seats.io "Displayed type", e.g. "Table",
+     * "Bench", "Box"), when the designer set one. Absent = the default word.
+     */
+    displayType?: string;
+    /** Chart object id (row/booth/GA area) the unit belongs to. */
+    objectId: string;
+    objectType: 'seat' | 'booth' | 'ga' | 'table';
+    categoryKey: string;
+    /** Chosen ticket tier id (Adult/Child/…), or null when the category has no tiers. */
+    tierId: string | null;
+    /** Unit price in MAJOR currency units (e.g. 45 = 45.00). Server-authoritative. */
+    unitPrice: number;
+    /** ISO-4217, resolved server-side (per-event override → org → USD). */
+    currency: string;
+    quantity: number;
+    /**
+     * The renderer's own seat id, when this line resolves to a placed object.
      *
-     * The token lives in memory for the widget's lifetime and nowhere else: never
-     * in storage, never in a URL, never in a log or an error message. Refresh
-     * returns the same or a narrower scope — the SDK never widens to Public sale
-     * on its own, and a failed refresh stops the scoped operation rather than
-     * retrying it anonymously.
+     * Present so a host can join a cart line to the same unit in `selection[]`
+     * by identity rather than by string label. Absent for a GA synthetic unit,
+     * which has no seat, and for a held line whose label no longer resolves.
      */
-    buyerAccessTokenProvider?: BuyerAccessTokenProvider;
+    seatId?: string;
     /**
-     * One-shot escape hatch for hosts that already own the session lifecycle.
-     * Cannot be renewed — when it lapses the widget reports `onAccessExpired`
+     * Buyer-facing spatial address — the same three fields a tapped seat carries.
+     *
+     * Best Available and a resumed hold both produce lines that were never in
+     * the renderer selection, so a host joining cart→selection to render "Stalls
+     * D · Row C · Seat 6" got nothing back and the line arrived anonymous. The
+     * address now travels ON the line, which is where the host reads it anyway.
+     * Absent when the chart does not carry that level of address.
+     */
+    sectionLabel?: string;
+    rowLabel?: string;
+    seatNumber?: string;
+}
+interface CheckoutHandoff {
+    /** Server hold id — pass this to YOUR book call. */
+    holdId: string;
+    /** Epoch ms the hold expires (after any extensions). */
+    expiresAt: number;
+    /** ISO-4217 currency for the whole order. */
+    currency: string;
+    /** Priced line items (tier + unit price + currency), server-authoritative. */
+    lineItems: CheckoutLineItem[];
+    /** Convenience total in major units (Σ unitPrice × quantity). */
+    total: number;
+}
+/** Host-authoritative pricing — see {@link SeatPickerOptions.pricing}. */
+interface SeatPickerPricing {
+    /** Unit prices by category key: a flat number, or `{ base, tiers: { tierId: price } }`. */
+    prices?: Record<string, number | {
+        base?: number;
+        tiers?: Record<string, number>;
+    }>;
+    /** Custom money renderer (e.g. `(n) => n + '€'`). Defaults to Intl currency formatting. */
+    formatter?: (amount: number, currency: string) => string;
+}
+/** Optional constraints for the server-authoritative best-available pick. */
+interface SeatPickerBestAvailableOptions {
+    /** Prefer a contiguous premium block, falling back to the best overall block. */
+    preferPremium?: boolean;
+    /** Restrict the search to one configured chart zone. */
+    zoneId?: string;
+}
+/** Buyer-facing surface shown by the full picker widget. */
+type SeatPickerBuyerView = 'map' | 'venue3d';
+/** Optional camera intent when switching the buyer-facing surface. */
+interface SeatPickerBuyerViewOptions {
+    /** Enter (or remain in) 3D and fly the camera to this seat id. */
+    flyToSeatId?: string;
+    /** When already in 3D, return the camera to the venue overview. */
+    resetView?: boolean;
+}
+/** Host theme overrides — any subset; unset keys fall back to the org's chart theme, then defaults. */
+interface SeatPickerTheme {
+    /**
+     * Light, dark, or follow the reader's own `prefers-color-scheme`.
+     *
+     * OPT-IN. Omit it and the widget renders exactly what it always did: the
+     * chart's authored ground, the organizer's colours, your own overrides. Set
+     * it and the built-in token set for that side takes the GROUND roles —
+     * background, surface, ink, muted ink, hairlines, and the drawn map's own
+     * canvas — while the organizer's accent, font, radius and logo, and every
+     * colour you state explicitly below, stay exactly as they are.
+     *
+     * `'auto'` is re-read live: a buyer who flips their phone into dark mode
+     * mid-purchase keeps their seats and their hold.
+     */
+    mode?: ThemeMode;
+    /** Brand accent (CTA, active chips, hold pill). */
+    accent?: string;
+    /** Ink on the accent (button labels). */
+    accentInk?: string;
+    /** Widget background. */
+    background?: string;
+    /** Panel/card surface color. */
+    surface?: string;
+    /** Primary text color. */
+    text?: string;
+    /** Secondary text color. */
+    muted?: string;
+    /** Hairline/border color. */
+    line?: string;
+    /** Font stack for all widget chrome. */
+    fontFamily?: string;
+    /** Corner radius base (px). */
+    radius?: number;
+    /** Header logo URL (falls back to the org logo from the chart theme, then a monogram). */
+    logoUrl?: string;
+    /** Brand/event fallback name for the monogram. */
+    brandName?: string;
+    /**
+     * The DRAWN MAP, which the tokens above deliberately do not reach.
+     *
+     * Everything else on this interface is CSS: it re-inks panels, buttons and
+     * the sidebar. The seat map is a canvas, painted from the chart document's
+     * own `ChartTheme`, so a host could re-ink the whole widget and still be
+     * looking at somebody else's dark venue in the middle of it (which is exactly
+     * what SeatLayer's own light event-page palettes did, found 2026-08-07).
+     *
+     * Nested rather than flattened because `background` already means the
+     * WIDGET's background here and the canvas ground is a different surface —
+     * two things one word cannot carry.
+     *
+     * Set it only when you can vouch for the result: these colours are drawn
+     * behind and beside live seat statuses (held, sold, selected), and the map is
+     * the one part of this widget a buyer has to be able to read.
+     */
+    map?: PickerMapTheme;
+}
+/** Fine-grained WebMCP exposure — see `SeatPickerOptions.webMcp`. */
+interface SeatPickerWebMcpOptions {
+    /** Also register `seatlayer_hold_selection`, which reserves the selection.
+     *  Default false: holds stay a human tap. */
+    holds?: boolean;
+    /**
+     * Exact, trustworthy origins whose in-page agents may discover these tools
+     * across an iframe boundary, for example `https://tickets.example.com`.
+     *
+     * Same-origin and browser-provided agents do not need this. Cross-origin
+     * embeds also need `allow="tools"` on the iframe. Never derive this list from
+     * request data; keep it as an explicit integrator allowlist.
+     */
+    exposedTo?: string[];
+}
+interface SeatPickerOptions {
+    /** CSS selector or element to mount into. Omit when using SeatPicker.open(). */
+    container?: string | HTMLElement;
+    /** Event key, e.g. `ev_xxx`. */
+    event: string;
+    /** API origin. Defaults to https://api.seatlayer.io. */
+    apiBase?: string;
+    /**
+     * Custom data transport. Defaults to the CORS-trivial PubApi against
+     * `apiBase`. Inject to run the widget against another backend adapter (the
+     * SeatLayer dashboard's own transport) or a fully local mock (demos).
+     */
+    transport?: PickerTransport;
+    /**
+     * Publishable account key (`pk_live_…` / `pk_test_…`) for a public
+     * Platform/SDK Event. With no explicit buyer-access token/provider, the SDK
+     * uses it to bootstrap one origin-bound, Public-sale-only session directly
+     * from SeatLayer and receives chart + inventory in the same request.
+     *
+     * This is not buyer identity and cannot request private channels. An explicit
+     * `buyerAccessTokenProvider` or `buyerAccessToken` below always takes
+     * precedence for login, presale, partner or other scoped inventory.
+     */
+    publicKey?: string;
+    /**
+     * Buyer access session provider — the recommended way to show private channel
+     * inventory (Sales Channels guide §6).
+     *
+     * Called with a `reason` whenever the widget needs a bearer: first
+     * acquisition, a near/actual expiry, a 401 `buyer_access_expired`, a realtime
+     * reconnect, or `refreshAccess()`. It should POST to YOUR backend, which
+     * mints the session with your secret key and returns `{ token, expiresAt }`.
+     *
+     * The token lives in memory for the widget's lifetime and nowhere else: never
+     * in storage, never in a URL, never in a log or an error message. Refresh
+     * returns the same or a narrower scope; the widget never widens to Public
+     * sale on its own, and a failed refresh stops the scoped operation rather
+     * than retrying it anonymously. Any held seats stay held — a hold is
+     * relinquished by its own opaque capability, not by channel access, so
+     * losing access never strands inventory (guide §9).
+     *
+     * Ignored when a custom `transport` is supplied: that host owns its own
+     * credentials.
+     */
+    buyerAccessTokenProvider?: BuyerAccessTokenProvider;
+    /**
+     * One-shot escape hatch for hosts that already own the session lifecycle.
+     * Cannot be renewed — when it lapses the widget reports `onAccessExpired`
      * and then `onAccessUnavailable`. Prefer `buyerAccessTokenProvider`.
      */
     buyerAccessToken?: string | BuyerAccessToken;
@@ -793,1444 +924,1423 @@ interface SeatingChartOptions {
     selectedObjects?: string[];
     /** Object ids or public labels the buyer may select. Omit for all free objects. */
     selectableObjects?: string[] | null;
-    /** Require exactly this many seated/table guest units before the selection is valid. */
+    /** Require exactly this many total seated/table/GA guest units before checkout. */
     numberOfPlacesToSelect?: number;
-    /** Optional local selection guards, enforced again before hold. */
+    /** Optional sale guards evaluated after every change and enforced before a
+     * hold: minimum quantity, consecutive seats, and/or no stranded singles. */
     selectionValidators?: PickerSelectionValidator[];
     /**
-     * BCP 47 language for the widget UI — `'de'`, `'es-MX'`, etc. Falls back to
-     * the browser language, then English. 37 languages ship. The German
-     * bundle (etc.) is fetched on demand so unused languages cost nothing.
+     * BCP 47 language for the widget UI. 37 languages ship; omit this and each
+     * buyer gets their own `navigator.languages`, falling back to English.
+     * Read once at render — there is no way to change it on a live chart.
      */
     locale?: string;
-    /**
-     * Per-key string overrides layered over the active locale — white-label copy
-     * without shipping a whole bundle, e.g. `{ 'map.fromPrice': 'ab {price}' }`.
-     */
+    /** Per-key string overrides layered over the active locale. */
     messages?: Record<string, string>;
     /**
-     * Show an in-chart language switcher offering exactly these languages.
+     * Show an in-picker language switcher offering exactly these languages.
      *
-     * Opt-in and curated on purpose: the chart sits inside someone else's page,
-     * a multilingual host already has its own switcher, and two that can
-     * disagree is worse than either alone. A curated list also beats all 37 — a
-     * German venue wants de/en/pl in the menu, not Welsh. Fewer than two
-     * resolvable entries renders nothing.
+     * Opt-in and curated on purpose. Omit it and there is no control: the widget
+     * sits inside someone else's page, and a multilingual host site already has
+     * its own switcher — two that can disagree is worse than either alone. A
+     * curated list also beats offering all 37: a German venue wants de/en/pl in
+     * the menu, not Welsh.
+     *
+     * Switching keeps the buyer's selection; it does not re-render the chart.
      */
     languages?: string[];
-    /** ISO 4217 currency for on-map prices (default USD). */
+    /** ISO 4217 currency fallback (the org/event currency on the chart wins). */
     currency?: string;
+    /** Colorblind-safe rendering (Okabe-Ito palette, hollow booked seats). */
+    colorblindSafe?: boolean;
     /**
-     * Colorblind-safe rendering: category hues switch to an Okabe-Ito palette
-     * and booked seats render hollow, so state never relies on hue alone.
-     * Toggleable later with setColorblindSafe().
+     * How a big chart's seats arrive: 'progressive' (default) shows the venue's
+     * sections as soon as the chart lands and fills the seats in a section at a
+     * time, nearest the viewport first; 'plain' builds the whole scene in one
+     * step. Small charts are built in one step either way.
      */
-    colorblindSafe?: boolean;
-    /** Host-authoritative colors for the drawn canvas, separate from native chrome. */
-    mapTheme?: PickerMapTheme;
-    /** Initial canvas projection.
-     * @deprecated `'isometric'` and `'perspective'` are retired in favour of the
-     * real 3D venue view (`setBuyerView('venue3d')`); they remain accepted for
-     * source compatibility and will be removed in the next major. Use `'flat'`. */
+    loadingReveal?: 'progressive' | 'plain';
+    /** Initial map projection. Buyers now toggle **Map (flat 2D) + 3D** only; the
+     * legacy `perspective` (2.5D) value is still ACCEPTED for source compatibility
+     * but is deprecated — it is coerced to `flat` with a one-time console warning.
+     * The 3D venue view is entered from the Map/3D control, not this option. */
     initialView?: RendererViewMode;
-    /** Offer the real, lazy-loaded interactive venue view. Default true. */
+    /**
+     * Offer the interactive 3D venue view (Map | 3D toggle + a "See it in 3D"
+     * action on the seat-confirm card). Default true. The 3D button is shown only
+     * when this is not false AND the browser exposes WebGL2; there are ZERO GL
+     * bytes on the wire until the buyer actually opens 3D (the OGL chunk is
+     * dynamically imported on first use). Set false for embed hosts that must
+     * stay strictly 2D. */
     enable3D?: boolean;
-    /** Offer authored/generated view-from-seat inspection. Default true. */
-    enableSeatView?: boolean;
-    /** Optional device-specific ceiling for offering the venue WebGL scene. */
+    /**
+     * Seat-count ceiling above which 3D is not offered. Default: 60,000 seats on
+     * desktop, reduced to 30,000 on a device that reports itself as small/low-core.
+     *
+     * The 53,018-seat evidence is desktop-only; that scale remains unmeasured on
+     * phones, which is why the small-device default stays conservative. The 3D
+     * scene holds every seat resident until a streaming rung exists. */
     max3DSeats?: number;
     /**
-     * Built-in seat tooltip on mouse hover (seat · category · price · status).
-     * Rendered inside the widget so every host gets it; default true. Turn off
-     * to draw your own popover from onSeatHover.
+     * Expose this picker to an AI agent running in the buyer's browser (WebMCP).
+     *
+     * Off by default and inert everywhere the API is absent (every WebView, every
+     * browser without it) — an integrator opts in per picker. `true` registers
+     * four tools: describe the event, search for seats (read-only — it never
+     * touches inventory), select seats on the map, and read the basket.
+     *
+     * `{ holds: true }` adds a fifth that reserves the selection, i.e. presses
+     * the checkout button. That is deliberately separate: a hold takes real
+     * inventory off the market, and an agent looping over events must not be able
+     * to lock a venue. Leave it off unless you want an agent to be able to commit.
+     *
+     * Cross-origin embeds: the HOST page must mark the iframe `allow="tools"`
+     * and the picker must list that host's exact origin in `exposedTo`, or an
+     * in-page agent in the host cannot discover the frame's tools.
      */
-    seatTooltip?: boolean;
-    /** Internal hosted-runtime control. Defaults true for direct web embeds. */
-    showTestModeIndicator?: boolean;
-    /** Internal hosted-runtime control. Defaults true, subject to white-label entitlement. */
-    showAttribution?: boolean;
+    webMcp?: boolean | SeatPickerWebMcpOptions;
     /**
-     * Seat hover with everything a popover needs (category label/color, resolved
-     * tier-aware price, live status, currency); null on hover-out. Fires whether
-     * or not the built-in tooltip is enabled.
+     * Fires when the buyer enters/leaves 3D or targets a seat there. Hosts can
+     * mirror this small, non-sensitive state into a shareable URL.
      */
-    onSeatHover?: (details: SeatHoverDetails | null) => void;
-    onSelectionChange?: (seats: SelectedSeat[]) => void;
-    /** Selection-rule state after each selection change. */
-    onSelectionValidityChange?: (state: PickerSelectionValidity) => void;
-    /** The configured selection rules have just become valid. */
-    onSelectionValid?: (seats: SelectedSeat[]) => void;
-    /** The configured selection rules have just become invalid. */
-    onSelectionInvalid?: (state: PickerSelectionValidity) => void;
-    /** A manual or programmatic selection reached the active maximum. */
-    onSelectionLimit?: (maxSelection: number) => void;
-    onHold?: (result: HoldResult) => void;
-    /** A prior active hold was restored with resumeHold(). */
-    onHoldRestored?: (result: HoldResult) => void;
-    onHoldExpired?: () => void;
-    onGAClick?: (area: GAAreaAvailability) => void;
+    onBuyerViewChange?: (state: {
+        view: SeatPickerBuyerView;
+        seatId?: string;
+    }) => void;
     /**
-     * Mirror of {@link SeatPickerOptions.onGAPrompt}. The low-level chart draws no
-     * quantity UI of its own, so this fires purely as the "the buyer wants to pick
-     * a quantity here" signal, with the same pre-computed `min`/`max`/`tiers` the
-     * full widget would have used; the return value is accepted and ignored.
-     */
-    onGAPrompt?: (prompt: GAPromptRequest) => boolean | void;
+     * Optional analytics sink for the widget's journey and performance events.
+     * Emits `chart_rendered` once per successful load with total time, step
+     * timings and anonymous chart-size counts, plus the 3D venue-view journey
+     * (`3d_opened`, `3d_orbit_engaged`, `3d_seat_picked`,
+     * `3d_cinematic_played`/`_skipped`/`_cancelled`, panorama outcomes, and WebGL
+     * context loss/recovery)
+     * with `{ surface: 'buyer' }` merged into the props. A throwing sink never
+     * breaks the widget. Route it to your product analytics (e.g. PostHog). */
+    onAnalytics?: (event: string, props: Record<string, unknown>) => void;
     /**
-     * The buyer access session lapsed. `refreshed` says whether the provider
-     * already recovered it — false means private inventory is now unavailable and
-     * `onAccessUnavailable` follows. Distinct from `onError` on purpose: this is
-     * never a network failure (guide §10).
+     * Every seat of a progressively revealed chart is now built and painted.
+     *
+     * `render()` resolves with the section shells and the nearest seats — the
+     * rest arrive in idle slices. A host that needs "the whole venue is on
+     * screen" waits for this rather than for `render()`. Fires exactly once per
+     * chart, and never for a chart small enough to build in one step (there is
+     * nothing to wait for: `render()` already was that moment).
      */
-    onAccessExpired?: (event: BuyerAccessExpiredEvent) => void;
+    onSeatsRevealed?: () => void;
     /**
-     * Private inventory is unavailable and refreshing will not fix it — revoked,
-     * paused, wrong origin/event/mode, or the provider failed. Carries a reason,
-     * never a channel name, id, colour or count.
+     * Optional organiser-defined campaign/referral label (max 120 characters).
+     * On the public SeatLayer transport it is frozen onto the hold, then copied
+     * to the Managed order, organiser reporting and booking webhook. It grants no
+     * inventory access and is ignored by host-supplied transports.
      */
-    onAccessUnavailable?: (event: BuyerAccessUnavailableEvent) => void;
+    referral?: string;
     /**
-     * Selected-but-unheld units stopped being selectable — someone else took
-     * them, or an allocation change moved them out of this buyer's scope. The
-     * widget has already dropped them from the selection.
+     * Hide the "Powered by SeatLayer" attribution badge in the side panel foot.
+     * The chart theme's own `hideBadge` flag (paid orgs) also hides it — the badge
+     * is shown only when BOTH this option and the theme flag are unset/false.
      */
-    onSelectedObjectUnavailable?: (event: SelectedObjectUnavailableEvent) => void;
-    onError?: (err: unknown) => void;
+    hideBadge?: boolean;
     /**
-     * What the BUYER sees when the chart cannot load.
-     *
-     * `'message'` (the default) renders a plain, styleable notice with a Try
-     * again button. This used to be silent unconditionally: `render()` returned
-     * with an EMPTY mounted div and only `onError` fired, so a host that had not
-     * wired `onError` — or had wired it to a logger — showed buyers a blank
-     * rectangle where the seat map belongs, on the host's own domain, which
-     * reads as a broken website rather than a temporary fault. `SeatPicker` has
-     * always failed loud with a retry; this is the embed class catching up.
+     * Hide the picker's event identity (logo, event name and venue/date metadata)
+     * when the host surface already presents the same event heading. The hold
+     * timer, sales status and modal close controls remain available. The identity
+     * is restored automatically while the picker is full screen so it never
+     * loses context on a small device or an expanded map. Default false.
      *
-     * `'none'` restores the silent behaviour for hosts that render their own
-     * failure UI from `onError`.
+     * A mounted host can update this through `setEventDetailsHidden()` when its
+     * own event chrome arrives asynchronously.
      */
-    errorDisplay?: 'message' | 'none';
+    hideEventDetails?: boolean;
     /**
-     * Multi-floor charts only: fires when the buyer taps a deck in the stacked
-     * 3D view, after the picker switches to that floor — lets the host page sync
-     * its own floor UI (tabs, labels) with the map.
+     * Start the wide-layout ticket panel collapsed so the map owns the full
+     * width (map-first hosts, small embeds). The buyer reopens it with the
+     * "Tickets" pill beside Map|3D, and it opens itself the moment a seat lands
+     * in the cart — a collapsed panel must never hide a checkout. Narrow
+     * layouts ignore this (the bottom sheet is already the collapse). A mounted
+     * host can drive it later through `setPanelCollapsed()`. Default false.
      */
-    onDeckTap?: (floorId: string) => void;
-    /** Big-venue section focus state for host-owned navigation chrome. */
-    onSectionFocus?: (summary: SectionSummary | null) => void;
-    /** Availability changed after a live frame or explicit refresh. */
-    onStatusChange?: () => void;
-    /** The server closed sales for this event. */
-    onSalesClosed?: () => void;
-    /** A programmatic/native map-control action changed serializable map state. */
-    onMapStateChange?: () => void;
-    /** rAF-coalesced camera-frame signal for in-page overlays; not native state. */
-    onViewChange?: () => void;
-    /** Real buyer-view transitions and 3D camera targets. */
-    onBuyerViewChange?: (state: {
-        view: SeatingChartBuyerView;
-        seatId?: string;
-    }) => void;
+    panelCollapsed?: boolean;
+    /** Host theme overrides — see SeatPickerTheme. */
+    theme?: SeatPickerTheme;
     /**
-     * Non-blocking, localized selection advice — currently the orphan-seat hint
-     * (the selection would strand a single free seat between taken neighbors).
-     * `null` clears it. Purely informational; nothing is ever prevented.
+     * Host-authoritative pricing. When your shop charges different prices than
+     * the chart's stored category prices, pass them here so the buyer sees the
+     * price they will actually pay — on the map tooltip, confirm popover, price
+     * panel, tray, totals, and in the checkout handoff's line items. Keyed by
+     * category key; per-tier overrides nest under `tiers`. Unlisted categories
+     * fall back to the chart price.
      */
-    onHint?: (message: string | null) => void;
-}
-declare class SeatingChart {
-    private readonly opts;
-    private readonly controller;
-    /** Publishable key used only by the public-only direct bootstrap path. */
-    readonly publicKey?: string;
-    private mount;
-    private hostEl;
+    pricing?: SeatPickerPricing;
     /**
-     * Native hosts can render a Flutter/Swift/Kotlin decision surface above this
-     * DOM tree. UIKit platform views still participate in hit testing beneath a
-     * composited native overlay, so the runtime must be able to make its own DOM
-     * inert rather than relying on the host's visual stacking alone.
+     * Fires when the server-resolved active offer changes. Hosted event pages use
+     * this to keep their headline, sticky bar and the canonical picker on the
+     * same live fact. The picker remains fully functional when it is omitted.
      */
-    private interactionEnabled_;
-    /** The organizer's language for this event, learned when the chart resolves. */
-    private eventLocale;
-    private rendered;
-    private mode_;
-    private eventInfo;
-    private maxSelection_;
-    private colorblindSafe_;
-    private categoryFilter_;
-    private accessibilityFilter_;
-    private hideLimitedView_;
-    private focusedSection_;
-    /** Last rung already exposed to native chrome; raw camera frames stay in-canvas. */
-    private lastReportedViewRung_;
-    private accessState_;
-    private tipEl;
-    private tipPos;
-    private onTipMove;
-    /** Null for the ordinary public chart — the tokenless path is untouched. */
-    private readonly access;
-    private readonly api;
-    private readonly apiBase;
-    private readonly buyerAssetUrls;
-    private readonly immersive;
-    private realtime;
-    constructor(options: SeatingChartOptions);
+    onOfferAvailabilityChange?: (availability: TicketOfferAvailability | null) => void;
+    /** Hold TTL in ms passed to hold(); server clamps to its own limits. */
+    holdTtlMs?: number;
     /**
-     * Camera x/y/scale is renderer-local and deliberately absent from the native
-     * picker snapshot. Keep pan and pinch frames on the canvas; only a semantic
-     * rung transition needs to wake native chrome.
+     * An opaque hold id supplied by the host to restore after navigation. It is
+     * verified against the event and active server state before anything renders
+     * as owned by this buyer.
      */
-    private handleViewChange;
-    /** Record the current rung before publishing an explicit state mutation. */
-    private notifyMapStateChange;
-    /** Fetch the chart, mount the renderer, seed statuses and go live. Idempotent. */
-    render(): Promise<this>;
+    initialHoldId?: string;
     /**
-     * Attribution badge pinned to the embed's bottom-right, linking to
-     * seatlayer.io. Rendered as an absolutely-positioned overlay with
-     * self-contained inline styles — the SDK embed ships no widget CSS, and an
-     * overlay keeps it out of the layout flow so it never disturbs the SDK v0.22
-     * fill-height resize contract. Mirrors the full widget's mark + wordmark and
-     * reuses the `picker.poweredBy` i18n string.
+     * Automatically remember the active hold id in sessionStorage and restore it
+     * when this event's picker mounts again. Default true. Set false when the host
+     * owns hold persistence and supplies initialHoldId itself.
      */
-    private buildBadge;
-    private placeTooltip;
-    private updateTooltip;
+    restoreHold?: boolean;
     /**
-     * Whether the SERVED event is a live or a test event (`sk_test_` keys create
-     * test events, which never book real inventory). `null` before render()
-     * resolves — the mode comes from the server with the chart, not from options.
-     *
-     * The widget already surfaces this visually with the test-mode ribbon; this
-     * getter is for hosts that draw their own chrome — notably a native WebView
-     * wrapper, which must be able to tell an integrator that the build they are
-     * about to ship is pointed at a test event.
+     * Render the real chart and live seat statuses without allowing selection,
+     * holds or checkout. This is for venue previews and pre-sale Website pages;
+     * it is enforced by the widget even if the event later opens while mounted.
+     * Default false.
      */
+    readOnly?: boolean;
     /**
-     * The opt-in language switcher, offering exactly the languages the host
-     * named. Absent unless `languages` lists at least two — a menu with one
-     * entry is furniture, and an unrequested one duplicates the switcher a
-     * multilingual host site already has.
-     *
-     * Each language names itself (`LOCALE_NAMES`): a reader scanning for their
-     * own language finds "Deutsch", never "German". An English list is
-     * unreadable to exactly the people who need it.
+     * Confirm mode: tapping a seat shows a confirmation card with section, row,
+     * seat, category, price and Select/Cancel before it enters the tray. Default
+     * true for the full buyer picker; set false only when the host supplies its
+     * own equivalent confirmation UI.
      */
-    private buildLanguageSwitcher;
+    confirmSelection?: boolean;
     /**
-     * Change the language of a LIVE chart, keeping the buyer's selection.
+     * Offer a "View from seat" 360° preview (confirm popover + tray chips). The
+     * panorama is generated from the chart geometry, or the organizer's uploaded
+     * photo when a seat carries one. Default true; set false to hide the affordance.
+     */
+    seatView?: boolean;
+    /**
+     * WHERE the buyer goes once their seats are held. Default `'handoff'`.
      *
-     * `locale` is otherwise read once at render, which is fine for a page that
-     * knows its language up front and useless for one with a language switcher.
-     * The competing embed API can only `rerender()`, and that clears the
-     * selection — losing someone's seats because they changed language is not an
-     * acceptable trade, so this rebuilds the map through `refreshMapCopy()`,
-     * which restores the selection on the far side.
+     *   'handoff'  (default, and every integration that has ever existed) the
+     *              widget fires {@link onCheckout} with a holdId and priced line
+     *              items, and YOUR server takes the money. Nothing about this path
+     *              changes, and no payment code is even downloaded.
+     *   'hosted'   the widget takes the money through the gateway the ORGANIZER
+     *              connected, on their account — the "sell tickets with no
+     *              backend" path. Requires the org to be on hosted checkout and
+     *              the event to have a gateway assigned; when it does not, this
+     *              falls back to `'handoff'` for that buyer rather than dead-ending
+     *              them, and reports why through {@link onCheckoutUnavailable}.
      *
-     * Returns the locale that actually became active: an unsupported or
-     * not-yet-translated tag resolves to English rather than throwing, exactly as
-     * it does at first render.
+     * Named for the destination rather than as a boolean flag because there is a
+     * real third answer coming and `hostedCheckout: true` would have no room for
+     * it; spelling the default out also makes a host's intent legible in their own
+     * source instead of hiding it in an absent option.
+     *
+     * TWO THINGS ARE WORTH KNOWING BEFORE YOU SWITCH THIS ON:
+     *
+     * 1. It needs the widget's own transport. A host-supplied `transport` owns its
+     *    credentials and its backend, so hosted checkout stays off there (with one
+     *    console warning) rather than reaching past it to api.seatlayer.io.
+     * 2. WHERE A HOSTED GATEWAY RETURNS THE BUYER is settled by {@link returnUrl}
+     *    and by the organizer. Without one — or from an origin the organizer has
+     *    not declared — the buyer comes back to SeatLayer's own buyer page and is
+     *    confirmed THERE, not in this widget. Declare the embedding site under
+     *    Embed domains in the dashboard and pass `returnUrl`, and the buyer
+     *    returns to your page instead. In-page gateways never navigate away at
+     *    all, so they are unaffected either way.
      */
-    setLocale(next: string | null | undefined): Promise<string>;
-    getMode(): 'live' | 'test' | null;
-    /** Atomic, token-free display state for native-owned picker chrome. */
-    getPickerState(): SeatingChartPickerState;
-    getCategoryAvailability(): Record<string, number>;
-    getBestAvailableZones(): Array<{
-        id: string;
-        label: string;
-    }>;
-    getActiveFloorId(): string | null;
-    getRung(): LodRung;
-    getFocusedSection(): string | null;
-    focusSection(sectionId: string): void;
-    overview(): void;
-    setRung(rung: LodRung): void;
-    setCategoryFilter(categoryKeys: string[] | null, focus?: boolean): void;
-    setAccessibilityFilter(types: string[] | null): void;
-    setCommercialLimitedFilter(on: boolean): void;
-    /** Current selection with prices resolved from the chart categories. */
-    getSelection(): SelectedSeat[];
-    /** Select free objects by engine id or public label. Returns newly selected objects. */
-    selectObjects(objects: string[]): SelectedSeat[];
-    /** Deselect objects by engine id or public label. */
-    deselectObjects(objects: string[]): void;
-    /** Clear every unheld selection. */
-    clearSelection(): void;
-    /** Select every selectable object in the named categories. */
-    selectCategories(categoryKeys: string[]): SelectedSeat[];
-    /** Deselect every selected object in the named categories. */
-    deselectCategories(categoryKeys: string[]): void;
-    /** Replace the buyer-selectable object allow-list without remounting. */
-    setSelectableObjects(objects: string[] | null): void;
-    /** Change the selection cap without remounting. */
-    setMaxSelection(maxSelection: number): void;
-    /** Current selection-rule validity, or null when no rules were configured. */
-    getSelectionValidity(): PickerSelectionValidity | null;
-    /** Hold the current selection. Resolves the hold, or null on a 409 conflict. */
-    hold(options?: {
-        ttlMs?: number;
-    }): Promise<HoldResult | null>;
+    checkout?: 'handoff' | 'hosted';
     /**
-     * @internal Like {@link hold} but RE-THROWS the structured API error (409
-     * `reason`/`code` + `conflicts`) instead of swallowing it into `onError` +
-     * `null`. The native WebView host adapter needs the throw so it can answer the
-     * originating command with a correlated error carrying the SPECIFIC reason
-     * (`sold_out` vs `not_enough_together`); the public method above keeps the
-     * catch-and-onError contract that direct web consumers rely on. Not a stable
-     * part of the embed API.
+     * Where a redirecting gateway should send the buyer back to, for
+     * `checkout: 'hosted'`.
+     *
+     * The server keeps this URL's path and query and adds only a non-secret
+     * `seatlayer_checkout=success|cancelled` outcome. The SDK keeps the order id
+     * in this tab's sessionStorage before leaving for the gateway. Point this at
+     * a page on the same origin (often `window.location.href`) and mount a picker
+     * there so it can resume without putting the order capability in a URL.
+     *
+     * It is validated, not trusted: the organizer declares their embed origins
+     * in the dashboard, and an undeclared origin is ignored rather than
+     * refused — the sale still completes, the buyer just finishes on
+     * SeatLayer's page. Supplying a URL therefore cannot authorize it, which is
+     * what stops a copied snippet from redirecting a paid buyer anywhere it
+     * likes.
+     * As with every script embed, code already running on the host origin can
+     * read that origin's sessionStorage; iframe embedding provides SOP isolation.
      */
-    holdOrThrow(options?: {
-        ttlMs?: number;
-    }): Promise<HoldResult | null>;
-    /** Restore an active hold by its opaque id without extending its expiry. */
-    resumeHold(holdId: string): Promise<HoldResult | null>;
-    /** @internal Throwing variant of {@link resumeHold} for the native host adapter. See {@link holdOrThrow}. */
-    resumeHoldOrThrow(holdId: string): Promise<HoldResult | null>;
+    returnUrl?: string;
     /**
-     * Push the OPEN hold's expiry out ("need more time?"). Resolves the refreshed
-     * hold, or `null` when there is nothing held or the server refused (the hold
-     * is gone, already expired, or at its renewal cap) — refusal is a normal
-     * outcome, not an error, so the host decides the copy. The client-side expiry
-     * timer is re-armed to match, so `onHoldExpired` won't fire early.
+     * Buyer pressed the CTA and the hold succeeded — hand off to YOUR checkout.
+     * `hold` and `seats` are the legacy args (unchanged since 0.6). `handoff` (P4)
+     * is the stable, self-contained {@link CheckoutHandoff} to build your order
+     * against — holdId, expiry, currency and priced line items. Prefer it.
+     *
+     * Under `checkout: 'hosted'` this fires ONLY when hosted checkout cannot run
+     * for this event, so a host can keep one code path for both. It never fires
+     * alongside a payment the widget is taking itself.
      */
-    extendHold(ttlMs?: number): Promise<HoldResult | null>;
-    /** Current active hold known to this chart, if any. */
-    getCurrentHold(): HoldResult | null;
-    getGAAreas(): GAAreaAvailability[];
-    holdGA(areaId: string, qty: number, options?: {
-        tierId?: string | null;
-        ttlMs?: number;
-    }): Promise<HoldResult | null>;
-    /** @internal Throwing variant of {@link holdGA} for the native host adapter. See {@link holdOrThrow}. */
-    holdGAOrThrow(areaId: string, qty: number, options?: {
-        tierId?: string | null;
-        ttlMs?: number;
-    }): Promise<HoldResult | null>;
+    onCheckout?: (hold: HoldResult, seats: PickerSeat[], handoff: CheckoutHandoff) => void;
     /**
-     * Ask the server for the `qty` best free seats and hold them atomically.
-     * `options.ttlMs` sets the checkout window exactly like {@link hold}; omit it
-     * and the server falls back to the event setting, then its own default.
+     * `checkout: 'hosted'` was asked for and this event cannot take money.
+     * The seats ARE held — the buyer is mid-journey — so this is a routing
+     * decision, not an error, and it is never collapsed into {@link onError}.
+     *
+     * `reason` carries the server's three-way answer verbatim, because two of the
+     * three give opposite advice: `payments_off_for_event` means the organizer
+     * deliberately does not sell this event online (nothing is wrong), while
+     * `unavailable_for_event` means they switched it on and it is broken. Anything
+     * unreadable — a failed lookup, an older worker — reads as `not_configured`,
+     * which asserts the least about them.
+     *
+     * `onCheckout` fires immediately after this with the same hold. Supply either
+     * (or both) and you own the next screen; supply NEITHER and the widget shows
+     * the buyer an honest card of its own rather than swallowing the press.
      */
-    bestAvailable(qty: number, categoryKey?: string, options?: {
-        zoneId?: string;
-        preferPremium?: boolean;
-        ttlMs?: number;
-    }): Promise<BestAvailableResult | null>;
-    /** @internal Throwing variant of {@link bestAvailable} for the native host adapter. See {@link holdOrThrow}. */
-    bestAvailableOrThrow(qty: number, categoryKey?: string, options?: {
-        zoneId?: string;
-        preferPremium?: boolean;
-        ttlMs?: number;
-    }): Promise<BestAvailableResult | null>;
+    onCheckoutUnavailable?: (event: {
+        reason: PaymentOptionsReason;
+        handoff: CheckoutHandoff;
+    }) => void;
     /**
-     * Choose a ticket tier for a selected seat (e.g. Adult → Child). The seat's
-     * available `tiers` are on each `SelectedSeat` from `getSelection()` /
-     * `onSelectionChange`. Re-emits the selection with the new tier + price, and
-     * the tier rides along in the next `hold()` / `onHold` per seat. `tierId=null`
-     * reverts to the default tier.
+     * `checkout: 'hosted'` only — the gateway's webhook landed and the order is
+     * PAID. The one signal a host with no backend actually needs, and the only
+     * place a receipt can come from on a page that has no server of its own.
+     *
+     * Distinct from {@link onBooked}, which reports the same sale seen from the
+     * seat map over the realtime channel and cannot fire at all for a buyer whose
+     * widget was torn down by a redirect to the gateway.
      */
-    setSeatTier(seatId: string, tierId: string | null): void;
-    /** Confirm/update an unheld variable table's guest quantity locally. */
-    setTableQuantity(label: string, quantity: number): boolean;
+    onOrderConfirmed?: (order: OrderStatusResult) => void;
     /**
-     * Atomically replace an active variable-table hold with a new guest count.
-     * Returns null for an inapplicable/invalid quantity or a refused replacement.
+     * The held seats were BOOKED (P4) — your server completed payment and the
+     * booking landed over the realtime channel while the widget was still open.
+     * The widget shows a success state; use this to advance your own UI (receipt,
+     * redirect). Fires once per hold.
      */
-    replaceTableQuantity(label: string, quantity: number, ttlMs?: number): Promise<HoldResult | null>;
-    /** @internal Throwing variant used by the correlated native bridge. */
-    replaceTableQuantityOrThrow(label: string, quantity: number, ttlMs?: number): Promise<HoldResult | null>;
+    onBooked?: (handoff: CheckoutHandoff) => void;
+    /** Selection changed (tap or best-available). */
+    onSelectionChange?: (seats: PickerSeat[]) => void;
+    /** Selection-rule state after each selection change. */
+    onSelectionValidityChange?: (state: PickerSelectionValidity) => void;
+    /** The configured selection rules have just become valid. */
+    onSelectionValid?: (seats: PickerSeat[]) => void;
+    /** The configured selection rules have just become invalid. */
+    onSelectionInvalid?: (state: PickerSelectionValidity) => void;
+    /** A selection attempt reached the active maximum. */
+    onSelectionLimit?: (maxSelection: number) => void;
     /**
-     * Floors of a multi-floor chart — `[{ id, name }]` (single-floor charts
-     * return one entry; empty before render()). Pair with setFloor() to build a
-     * host-side floor switcher.
+     * Active hold changed because it was created, restored, extended, partially
+     * released, or fully released. Hosts should persist this state for route
+     * navigation and clear their checkout cart when `hold` becomes null.
      */
-    getFloors(): {
-        id: string;
-        name: string;
-    }[];
-    /** Switch the shown floor (2D). Warns + no-ops on single-floor charts. */
-    setFloor(floorId: string): void;
-    /** Toggle colorblind-safe rendering at runtime (see options.colorblindSafe). */
-    setColorblindSafe(on: boolean): void;
-    /** Switch the 2D canvas projection.
-     * @deprecated `'isometric'` and `'perspective'` are retired in favour of the
-     * real 3D venue view (`setBuyerView('venue3d')`); accepted for source
-     * compatibility until the next major. */
-    setViewMode(mode: RendererViewMode): void;
-    /** Current canvas projection. */
-    getViewMode(): RendererViewMode;
-    /** Zoom in one step (same increment as the wheel/pinch gesture). */
-    zoomIn(): void;
-    /** Zoom out one step. */
-    zoomOut(): void;
-    /** Reset the camera so the whole chart fits the container. */
-    zoomToFit(): void;
-    /** Enter or leave the same real lazy-loaded venue scene as SeatPicker. */
-    setBuyerView(view: SeatingChartBuyerView, options?: {
-        flyToSeatId?: string;
-        resetView?: boolean;
-    }): Promise<void>;
-    getBuyerView(): SeatingChartBuyerView;
-    /** Open an authored or chart-derived 360° view for one physical seat. */
-    openSeatView(seatId: string): Promise<void>;
-    /** Explicit Rotate / Move control for native and custom picker chrome. */
-    setVenue3DNavigationMode(mode: SeatingChartNavigationMode): void;
+    onHoldChange?: (hold: HoldResult | null, seats: PickerSeat[], handoff: CheckoutHandoff | null) => void;
+    /** The open hold expired server-side (widget already reset itself). */
+    onHoldExpired?: () => void;
+    /** A prior active hold was verified and restored into the tray. */
+    onHoldRestored?: (hold: HoldResult, seats: PickerSeat[], handoff: CheckoutHandoff) => void;
+    /** Modal only: the buyer closed the picker (ESC / scrim / ✕). */
+    onClose?: () => void;
     /**
-     * Enable or suppress all buyer input inside this chart without unmounting it.
-     *
-     * Native SDKs use this while a native confirmation, quantity prompt, loading
-     * surface or error surface owns the chart area. Disabling input in the DOM is
-     * intentional: an iOS WKWebView can receive the same physical tap beneath a
-     * Flutter overlay even when the Flutter widget is wrapped in IgnorePointer.
-     * Programmatic bridge commands continue to work, so a prompt can still open
-     * view-from-seat or 3D and then re-enable interaction after the handoff.
+     * The buyer access session lapsed. `refreshed` says whether the provider
+     * already recovered it — false means private inventory is now unavailable and
+     * `onAccessUnavailable` follows. Never collapsed into `onError`: an expiry is
+     * a recoverable, buyer-explainable state, not a network failure (guide §10).
      */
-    setInteractionEnabled(enabled: boolean): void;
-    private applyInteractionState;
-    /** Release the current hold (if any). No-op when nothing is held. */
-    release(): Promise<void>;
-    /** Release selected labels from the current hold while keeping the remainder. */
-    releaseLabels(labels: string[]): Promise<boolean>;
-    /** Tear everything down: close the socket, stop timers, drop the canvas. */
+    onAccessExpired?: (event: BuyerAccessExpiredEvent) => void;
     /**
-     * Realtime for an access-scoped chart.
-     *
-     * A tokenless chart never gets here: `access` is null, `PubApi.socketUrl()`
-     * returns the URL it always has, and PickerController keeps its own socket
-     * and its own legacy frames. Nothing about the public path changes.
+     * Private inventory is unavailable and refreshing will not fix it — revoked,
+     * paused, wrong origin/event/mode, or the provider failed. Carries a reason,
+     * never a channel name, id, colour or count. The widget shows its own
+     * explanatory panel; return nothing to keep it, or handle the state yourself.
      */
-    private startRealtime;
-    /** Re-read live inventory without remounting or dropping buyer state. */
-    refreshAvailability(): Promise<void>;
+    onAccessUnavailable?: (event: BuyerAccessUnavailableEvent) => void;
     /**
-     * Re-acquire the buyer access session — call after your app has re-authorized
-     * the buyer (a revoked session cannot be recovered any other way). Resolves
-     * true when a fresh bearer is held; the realtime feed restarts with it.
+     * Selected-but-unheld units stopped being selectable — someone else took
+     * them, or an allocation change moved them out of this buyer's scope. The
+     * widget has already dropped them from the tray.
      */
-    refreshAccess(): Promise<boolean>;
+    onSelectedObjectUnavailable?: (event: SelectedObjectUnavailableEvent) => void;
     /**
-     * The visible failure state. Deliberately inline-styled and dependency-free:
-     * this renders on a stranger's website, where our stylesheet may not have
-     * loaded (the chart fetch just failed) and where inheriting the host's own
-     * styles is likelier to produce something unreadable than something on-brand.
-     */
-    private showLoadFailure;
-    destroy(): void;
-}
-
-/**
- * seatingChartBinding — the single source of truth the framework wrappers bind
- * against.
- *
- * `@seatlayer/react`, `@seatlayer/vue` and `@seatlayer/angular` are supposed to
- * be thin: mount a `SeatingChart`, forward the props, forward the callbacks,
- * expose the imperative handle. In practice each of them hand-wrote all three
- * lists, and they drifted — React grew `initialView` and `errorDisplay` props
- * that Vue and Angular never got, and nothing in any build caught it, because a
- * missing prop in a hand-written list is not a type error anywhere.
- *
- * So the lists live here, next to the class they describe, and the wrappers
- * iterate them. Adding a method to `SeatingChart` that buyers should be able to
- * call now means adding one entry to {@link SEATING_CHART_HANDLE_METHODS}; every
- * wrapper picks it up, and the wrapper tests fail until each one exposes it.
- *
- * Types only against `SeatingChart` — this module imports no runtime value from
- * it, so it costs a host nothing but the two arrays and the binder below.
- */
+     * A buyer tapped a general-admission area (on the map, or in the tray's
+     * `Areas` list) and the widget is about to open its own quantity prompt.
+     *
+     * Return `true` to take the interaction over completely — the built-in
+     * popover/sheet is suppressed, and the host drives the choice with whatever
+     * UI it likes, landing the result through `prompt.confirm(quantity)` (a plain
+     * number for a single-tier area, or `{ [tierId]: quantity }`) or dropping it
+     * with `prompt.cancel()`. Return anything else (or nothing) and the built-in
+     * prompt opens as usual, so this is also usable as a plain notification.
+     *
+     * `prompt.max` already folds in the area's live availability AND the
+     * order-wide ticket cap minus everything chosen elsewhere; a `confirm` above
+     * it is clamped rather than rejected.
+     */
+    onGAPrompt?: (prompt: GAPromptRequest) => boolean | void;
+    onError?: (err: unknown) => void;
+}
 
 /**
- * Imperative handle exposed by every wrapper — call these to drive the picker
- * from your app.
+ * SeatingChart — the embeddable buyer picker.
  *
- * Angular is the one exception to the naming: its component surfaces `hold` as
- * `holdSelection`, because `hold` is already taken by its `@Output()` event.
+ * A thin wrapper over the shared PickerController (src/picker/PickerController):
+ * it owns the mount <div> + the public embed contract (hold-only — the SDK hands
+ * the holdId to the host page for a server-side book) and delegates all transport
+ * + booking to the controller, so the SDK inherits every fix made for the live
+ * buyer page and the demo picker.
  */
-interface SeatingChartHandle {
-    /** Hold the current selection. Resolves the hold, or `null` on a 409 conflict. */
-    hold(options?: {
-        ttlMs?: number;
-    }): Promise<HoldResult | null>;
-    /** Restore an active hold by its opaque id. */
-    resumeHold(holdId: string): Promise<HoldResult | null>;
-    /** Current active hold known to the chart. */
-    getCurrentHold(): HoldResult | null;
-    /** GA areas with live remaining capacity. */
-    getGAAreas(): GAAreaAvailability[];
-    /** Atomically hold a quantity from one GA area. */
-    holdGA(areaId: string, qty: number, options?: {
-        tierId?: string | null;
-        ttlMs?: number;
-    }): Promise<HoldResult | null>;
-    /** Ask the server for the `qty` best free seats and hold them atomically. */
-    bestAvailable(qty: number, categoryKey?: string): Promise<BestAvailableResult | null>;
-    /** Release the current hold (if any). */
-    release(): Promise<void>;
-    /** Release some held labels while keeping the remainder active. */
-    releaseLabels(labels: string[]): Promise<boolean>;
-    /** The current selection, with prices resolved from the chart categories. */
-    getSelection(): SelectedSeat[];
-    /** Select free objects by engine id or public label. */
-    selectObjects(objects: string[]): SelectedSeat[];
-    /** Deselect objects by engine id or public label. */
-    deselectObjects(objects: string[]): void;
-    /** Clear every unheld selection. */
-    clearSelection(): void;
-    /** Select every selectable object in the named categories. */
-    selectCategories(categoryKeys: string[]): SelectedSeat[];
-    /** Deselect every selected object in the named categories. */
-    deselectCategories(categoryKeys: string[]): void;
-    /** Replace the buyer-selectable object allow-list without rebuilding. */
-    setSelectableObjects(objects: string[] | null): void;
-    /** Change the selection cap without rebuilding. */
-    setMaxSelection(maxSelection: number): void;
-    /** Current exact-count validity, or null when no exact count was configured. */
-    getSelectionValidity(): PickerSelectionValidity | null;
-    /**
-     * Choose a ticket tier for a selected seat (e.g. Adult → Child). Available
-     * `tiers` are on each `SelectedSeat`; `tierId=null` reverts to the default.
-     */
-    setSeatTier(seatId: string, tierId: string | null): void;
-    /**
-     * Floors of a multi-floor chart — `[{ id, name }]` (single-floor charts
-     * return one entry; empty before render()). Pair with setFloor().
-     */
-    getFloors(): {
+
+/** A seat as surfaced to the host page (prices resolved from the chart's categories). */
+type SelectedSeat = PickerSeat;
+interface GAAreaAvailability {
+    id: string;
+    label: string;
+    capacity: number;
+    available: number;
+    categoryKey: string;
+    price: number;
+    currency: string;
+    /** Buyer-facing copy authored separately from stable inventory identity. */
+    displayLabel?: string;
+    displayType?: string;
+    tiers?: Array<{
         id: string;
         name: string;
-    }[];
-    /** Switch the shown floor (2D). Warns + no-ops on single-floor charts. */
-    setFloor(floorId: string): void;
-    /** Toggle colorblind-safe rendering at runtime (see the `colorblindSafe` prop). */
-    setColorblindSafe(on: boolean): void;
-    /** Zoom in one step (same increment as the wheel/pinch gesture). */
-    zoomIn(): void;
-    /** Zoom out one step. */
-    zoomOut(): void;
-    /** Reset the camera so the whole chart fits the container. */
-    zoomToFit(): void;
-    /**
-     * Re-acquire the buyer access session after your app re-authorizes the buyer
-     * (Sales Channels). Resolves false when the chart is not access-scoped.
-     */
-    refreshAccess(): Promise<boolean>;
+        price: number;
+    }>;
 }
 /**
- * Every method a wrapper must forward. The wrappers build their handle by
- * iterating this, so the list IS the contract rather than a description of it.
- */
-declare const SEATING_CHART_HANDLE_METHODS: readonly ["hold", "resumeHold", "getCurrentHold", "getGAAreas", "holdGA", "bestAvailable", "release", "releaseLabels", "getSelection", "selectObjects", "deselectObjects", "clearSelection", "selectCategories", "deselectCategories", "setSelectableObjects", "setMaxSelection", "getSelectionValidity", "setSeatTier", "getFloors", "setFloor", "setColorblindSafe", "zoomIn", "zoomOut", "zoomToFit", "refreshAccess"];
-type SeatingChartHandleMethod = (typeof SEATING_CHART_HANDLE_METHODS)[number];
-/**
- * Build the forwarding object every wrapper exposes.
- *
- * `getInstance` is a function rather than the instance itself: a wrapper's
- * handle is created ONCE and must keep working across rebuilds, so it has to
- * read the current chart on each call instead of capturing one.
- */
-declare function bindSeatingChartHandle(getInstance: () => SeatingChart | null): SeatingChartHandle;
-/**
- * Props whose change means a DIFFERENT chart, so the wrapper tears the canvas
- * down and builds a new one. Everything else is read live: a parent re-render
- * must never destroy a canvas mid-selection.
- *
- * `initialView` and `errorDisplay` are here because they are read once at
- * construction and never re-applied — leaving them out does not make them
- * "live", it makes them silently ignored after mount, which is the worse of the
- * two behaviours. React already treated them this way; Vue and Angular did not
- * expose them at all.
- */
-declare const SEATING_CHART_IDENTITY_PROPS: readonly ["event", "apiBase", "maxSelection", "numberOfPlacesToSelect", "selectionValidators", "publicKey", "locale", "currency", "colorblindSafe", "initialView", "errorDisplay"];
-type SeatingChartIdentityProp = (typeof SEATING_CHART_IDENTITY_PROPS)[number];
-/** Non-callback options a wrapper accepts as props/inputs and passes straight through. */
-declare const SEATING_CHART_VALUE_PROPS: readonly ["event", "apiBase", "maxSelection", "numberOfPlacesToSelect", "selectionValidators", "publicKey", "locale", "currency", "colorblindSafe", "initialView", "errorDisplay", "selectedObjects", "selectableObjects", "messages", "seatTooltip", "buyerAccessTokenProvider", "buyerAccessToken"];
-type SeatingChartValueProp = (typeof SEATING_CHART_VALUE_PROPS)[number];
-/** Every callback option a wrapper wires to its own event mechanism. */
-declare const SEATING_CHART_CALLBACK_PROPS: readonly ["onSelectionChange", "onSelectionValidityChange", "onSelectionValid", "onSelectionInvalid", "onSelectionLimit", "onHold", "onHoldRestored", "onHoldExpired", "onGAClick", "onGAPrompt", "onError", "onDeckTap", "onHint", "onSeatHover", "onAccessExpired", "onAccessUnavailable", "onSelectedObjectUnavailable"];
-type SeatingChartCallbackProp = (typeof SEATING_CHART_CALLBACK_PROPS)[number];
-/** The value half of the options, as a wrapper holds it. */
-type SeatingChartValues = Pick<SeatingChartOptions, SeatingChartValueProp>;
-/** The callback half, already bound to the wrapper's event mechanism. */
-type SeatingChartCallbacks = Pick<SeatingChartOptions, SeatingChartCallbackProp>;
-/**
- * Assemble the options literal for `new SeatingChart(...)`.
- *
- * Picks by the lists above rather than spreading, so a wrapper cannot pass a
- * stray prop of its own (React's `className`/`style`, Vue's attrs) into the
- * SDK, and cannot forget one either.
- */
-declare function buildSeatingChartOptions(container: HTMLElement, values: Partial<SeatingChartValues>, callbacks: SeatingChartCallbacks): SeatingChartOptions;
-
-/**
- * A secure, framework-neutral host for the SeatLayer chart Designer.
- *
- * The Designer remains an iframe so a platform never gives its SeatLayer secret
- * key to a browser. This class owns the iframe lifecycle and accepts messages
- * only from that iframe's exact origin.
+ * Serializable state exposed to hosted native picker chrome. It deliberately
+ * contains buyer-display data only: never API keys, buyer-access bearers,
+ * provider callbacks, or the active hold id.
  */
-type EmbeddedDesignerEventType = 'seatlayer.designer.ready' | 'seatlayer.designer.saved' | 'seatlayer.designer.published' | 'seatlayer.designer.close' | 'seatlayer.designer.error';
-interface EmbeddedDesignerMessage {
-    type: EmbeddedDesignerEventType;
-    chartId?: string;
-    workspaceId?: string;
-    expiresAt?: number;
-    code?: string;
-    message?: string;
-    meta?: unknown;
-    /**
-     * Set by the Designer on an error it raised while the editor was already
-     * running (a failed autosave, thumbnail upload, reload…). Such an error is
-     * about ONE operation, not about the session, so the SDK reports it to the
-     * host and leaves the live editor mounted instead of replacing it with the
-     * dead-end card. Absent on older Designer builds — see
-     * {@link EmbeddedDesigner} for the phase-based fallback.
-     */
-    fatal?: boolean;
-    /** The operation that failed, when `fatal` is `false` (e.g. `'save'`). */
-    action?: string;
-}
-interface EmbeddedDesignerOptions {
-    /** The short-lived URL returned by your backend's Designer-session call. */
-    designerUrl: string;
-    /** CSS selector or element where the iframe is mounted. */
-    container: string | HTMLElement;
-    /**
-     * Verify the message belongs to the chart your backend opened. When set, the
-     * id is required on `ready` and every runtime lifecycle message. Only an error
-     * raised before the iframe resolves its session may omit it.
-     */
-    expectedChartId?: string;
-    /**
-     * Verify the message belongs to the workspace your backend opened. Uses the
-     * same ready/runtime requirement and pre-session error exception as
-     * `expectedChartId`.
-     */
-    expectedWorkspaceId?: string;
-    title?: string;
-    className?: string;
-    style?: Partial<CSSStyleDeclaration>;
-    allow?: string;
-    referrerPolicy?: ReferrerPolicy;
-    /**
-     * Show the built-in branded loading skeleton and error/expiry card inside the
-     * container while the Designer boots. Defaults to `true`. Set `false` when the
-     * host renders its own loading and error chrome.
-     */
-    showLoadingState?: boolean;
+interface SeatingChartPickerState {
+    event: {
+        key: string;
+        name: string;
+        venue: string | null;
+        startsAt: number | null;
+        timezone: string | null;
+        currency: string;
+        locale: string | null;
+        posterUrl: string | null;
+        mode: 'live' | 'test';
+        salesClosed: boolean;
+    };
+    branding: {
+        accent?: ChartTheme['accent'];
+        accentInk?: ChartTheme['accentInk'];
+        background?: ChartTheme['background'];
+        textColor?: ChartTheme['textColor'];
+        brandName?: ChartTheme['brandName'];
+        logoUrl?: ChartTheme['logoUrl'];
+        /** Native must render SeatLayer attribution when it owns chrome and this is true. */
+        attributionRequired: boolean;
+    };
+    features: {
+        ga: boolean;
+        tiers: boolean;
+        floors: boolean;
+        zones: boolean;
+        sections: boolean;
+        bestAvailable: boolean;
+        accessibilityFilter: boolean;
+        limitedViewFilter: boolean;
+        /** Real lazy-loaded WebGL venue view, not the retired isometric projection. */
+        venue3d: boolean;
+        /** Authored or chart-derived view-from-seat panorama. */
+        seatView: boolean;
+    };
+    catalog: {
+        categories: Array<{
+            key: string;
+            label: string;
+            color: string;
+            price: number;
+            available: number;
+            tiers: Array<{
+                id: string;
+                name: string;
+                price: number;
+                currency?: string;
+            }>;
+        }>;
+        zones: Array<{
+            id: string;
+            label: string;
+            color?: string;
+        }>;
+        sections: Array<{
+            id: string;
+            label: string;
+            displayLabel?: string;
+            zoneId?: string;
+        }>;
+        gaAreas: GAAreaAvailability[];
+        bestAvailableZones: Array<{
+            id: string;
+            label: string;
+        }>;
+    };
+    map: {
+        floors: Array<{
+            id: string;
+            name: string;
+        }>;
+        activeFloorId: string | null;
+        rung: LodRung;
+        focusedSectionId: string | null;
+        focusedSection: SectionSummary | null;
+        viewMode: RendererViewMode;
+        buyerView: SeatingChartBuyerView;
+        view3dTargetSeatId: string | null;
+        view3dNavigationMode: SeatingChartNavigationMode;
+        colorblindSafe: boolean;
+        /** Chrome the HOST draws over the map, in CSS px, echoed back so a native
+         *  shell can confirm what framing is honouring. Zero when none reported. */
+        viewportInsets: {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+        categoryFilter: string[] | null;
+        accessibilityFilter: string[] | null;
+        hideLimitedView: boolean;
+    };
+    selection: {
+        seats: SelectedSeat[];
+        validity: PickerSelectionValidity | null;
+        maxSelection: number;
+    };
+    access: {
+        configured: boolean;
+        status: 'public' | 'ready' | 'expired' | 'unavailable';
+        reason?: string;
+    };
+}
+interface SeatingChartOptions {
+    /** CSS selector or an HTMLElement to render into. */
+    container: string | HTMLElement;
+    /** Event key, e.g. `ev_xxx`. */
+    event: string;
+    /** API origin. Defaults to https://api.seatlayer.io. */
+    apiBase?: string;
     /**
-     * If the Designer never posts `ready` within this many milliseconds, the host
-     * transitions to the error card with a timeout message. Defaults to `20000`.
-     * Only used when `showLoadingState` is enabled.
+     * Publishable account key for direct Public-sale bootstrap of a Platform/SDK
+     * Event. It is never buyer identity and cannot request private inventory.
+     * An explicit buyer-access provider/token below always takes precedence.
      */
-    loadingTimeoutMs?: number;
+    publicKey?: string;
     /**
-     * How to size the iframe's height. The Designer is a full application (its
-     * shell is `position:fixed; height:100dvh`), not flowing content, so it should
-     * fill its box rather than be measured.
-     *
-     * - `'fill'` (default): container-aware. On mount the SDK probes whether the
-     *   host gave the container a DEFINITE (bounded) height:
-     *     - **Bounded container** (a fixed-height block, `height`/`max-height`,
-     *       `flex:1; min-h:0`, a resolved `%`, etc.) → the iframe fills 100% of
-     *       that block and tracks its size live via a `ResizeObserver`.
-     *     - **Content-sized container** (the block collapses to whatever the iframe
-     *       measures — typical full-page usage) → the iframe grows so its bottom
-     *       edge reaches the bottom of the viewport (`window.innerHeight -
-     *       iframe.top`), recomputed (rAF-throttled) on `resize` /
-     *       `orientationchange` / `scroll`.
-     *   Either way the result is clamped to `minHeight`. The verdict is cached but
-     *   re-probed on `resize`/`orientationchange` so a responsive host layout can
-     *   flip between the two. The legacy `seatlayer.designer.resize` message is
-     *   ignored in `'fill'` mode: it is circular, because the fixed-position shell
-     *   just echoes the iframe height.
-     * - a number: a fixed pixel height. In this mode the legacy resize message is
-     *   still honoured (unless `autoResize` is `false`) so older hosts keep growing.
+     * Buyer access session provider — the recommended way to render private
+     * channel inventory (Sales Channels guide §6).
      *
-     * All SDK-managed heights are written with `!important` priority so a host
-     * theme's `iframe { height: … !important }` cannot override them.
-     */
-    height?: 'fill' | number;
-    /** Minimum height (px) that `'fill'` mode clamps to. Defaults to `480`. */
-    minHeight?: number;
-    /**
-     * Auto-grow the iframe to the height the Designer reports over the resize
-     * protocol (`seatlayer.designer.resize`). Only applies when `height` is a fixed
-     * number; ignored in `'fill'` mode. Defaults to `true`. Set `false` when the
-     * host sizes a fixed-height iframe itself.
-     */
-    autoResize?: boolean;
-    /**
-     * Called when the user presses "Try again" on the error card. Use it to mint a
-     * fresh Designer session and call `setDesignerUrl()` with the new URL, which
-     * recreates the iframe and returns to the loading state. When omitted, "Try
-     * again" reloads the current `designerUrl` in place.
+     * Called with a `reason` whenever the SDK needs a bearer: first acquisition,
+     * a near/actual expiry, a 401 `buyer_access_expired`, a realtime reconnect,
+     * or `refreshAccess()`. It should POST to YOUR backend, which mints the
+     * session with your secret key and returns `{ token, expiresAt }`.
      *
-     * When supplied, it also powers automatic session renewal — see
-     * {@link EmbeddedDesignerOptions.autoRenewSession}.
+     * The token lives in memory for the widget's lifetime and nowhere else: never
+     * in storage, never in a URL, never in a log or an error message. Refresh
+     * returns the same or a narrower scope — the SDK never widens to Public sale
+     * on its own, and a failed refresh stops the scoped operation rather than
+     * retrying it anonymously.
      */
-    onRequestRelaunch?: () => void;
+    buyerAccessTokenProvider?: BuyerAccessTokenProvider;
     /**
-     * Keep long editing sessions alive without the user ever hitting the expiry
-     * wall. Designer sessions are short-lived security tokens; when the host wires
-     * `onRequestRelaunch` the SDK, with this enabled, will:
-     *
-     * - **Renew proactively.** From each `ready` message's `expiresAt` it schedules
-     *   a silent relaunch shortly before the session lapses (~3 min ahead; for a
-     *   TTL under 15 min it renews after 80% of the remaining life, and never
-     *   sooner than 30s after `ready`). The host mints a fresh session and swaps
-     *   `designerUrl`, so the editor keeps working with no error card.
-     * - **Recover on expiry.** If an expiry error still slips through (a slept
-     *   laptop woke past the renewal window, say) it makes ONE automatic relaunch
-     *   attempt before showing the "Try again" card, and only falls back to the
-     *   card if that relaunch also fails.
-     *
-     * Defaults to `true` whenever `onRequestRelaunch` is provided; a no-op without
-     * it. Set `false` to keep the fully manual "Try again" behavior.
+     * One-shot escape hatch for hosts that already own the session lifecycle.
+     * Cannot be renewed — when it lapses the widget reports `onAccessExpired`
+     * and then `onAccessUnavailable`. Prefer `buyerAccessTokenProvider`.
      */
-    autoRenewSession?: boolean;
-    onReady?: (message: EmbeddedDesignerMessage) => void;
-    onSaved?: (message: EmbeddedDesignerMessage) => void;
-    onPublished?: (message: EmbeddedDesignerMessage) => void;
-    onClose?: (message: EmbeddedDesignerMessage) => void;
-    onError?: (message: EmbeddedDesignerMessage) => void;
-}
-/** Mount, replace, and destroy a scoped Designer iframe safely. */
-declare class EmbeddedDesigner {
-    private options;
-    private frame;
-    private designerOrigin;
-    private overlay;
-    private timeoutTimer;
-    /** Proactive session-renewal timer; armed from each `ready`, cleared on re-mount. */
-    private renewTimer;
-    /** Last identity-checked session expiry, so a live policy change can re-arm. */
-    private sessionExpiresAt;
+    buyerAccessToken?: string | BuyerAccessToken;
+    /** Max seats selectable at once (default 10). */
+    maxSelection?: number;
+    /** Object ids or public labels selected after live availability is loaded. */
+    selectedObjects?: string[];
+    /** Object ids or public labels the buyer may select. Omit for all free objects. */
+    selectableObjects?: string[] | null;
+    /** Require exactly this many seated/table guest units before the selection is valid. */
+    numberOfPlacesToSelect?: number;
+    /** Optional local selection guards, enforced again before hold. */
+    selectionValidators?: PickerSelectionValidator[];
     /**
-     * One automatic recovery relaunch is allowed per expiry. Reset ONLY when a fresh
-     * `ready` arrives — deliberately not on re-mount — so a session that keeps failing
-     * to load can't loop the host through endless silent relaunches.
+     * BCP 47 language for the widget UI — `'de'`, `'es-MX'`, etc. Falls back to
+     * the browser language, then English. 37 languages ship. The German
+     * bundle (etc.) is fetched on demand so unused languages cost nothing.
      */
-    private autoRecoverUsed;
-    private phase;
+    locale?: string;
     /**
-     * Set only after an identity-checked `ready`. Unlike `phase`, this remains true
-     * if a later fatal error renders the error card, so no subsequent callback can
-     * shed the chart/workspace identity the live session already established.
+     * Per-key string overrides layered over the active locale — white-label copy
+     * without shipping a whole bundle, e.g. `{ 'map.fromPrice': 'ab {price}' }`.
      */
-    private identityEstablished;
-    private restoreContainerPosition;
-    private pinned;
-    private frameStyleBeforeFs;
-    private docOverflowBeforeFs;
-    private bodyOverflowBeforeFs;
-    private fsKeyHandler;
-    /** Latest height (px string) the Designer reported; re-applied after unpin. */
-    private lastAutoHeight;
-    private fillRaf;
-    private reprobeRaf;
-    private fillListening;
-    /** Resolved container element (fill measurement + ResizeObserver target). */
-    private containerEl;
-    /** Cached fill verdict: 'container' = bounded block, 'viewport' = full page. */
-    private fillMode;
-    /** Live block-size tracking in container-fill mode; disconnected on destroy. */
-    private resizeObs;
-    constructor(options: EmbeddedDesignerOptions);
-    mount(): HTMLIFrameElement;
-    /** Replace the iframe instead of assigning a new fragment to an existing one. */
-    setDesignerUrl(designerUrl: string): HTMLIFrameElement;
-    getIframe(): HTMLIFrameElement | null;
-    /** Update iframe sizing without replacing the live Designer session. */
-    setSizing(height: 'fill' | number | undefined, minHeight: number | undefined): void;
-    /** Update renewal/expiry-recovery policy without replacing the iframe. */
-    setRelaunchPolicy(onRequestRelaunch: (() => void) | undefined, autoRenewSession: boolean | undefined): void;
-    destroy(): void;
-    private loadingStateEnabled;
-    private autoResizeEnabled;
-    /** Fill mode is the default; a numeric `height` opts into a fixed pixel box. */
-    private fillEnabled;
-    /** Write an SDK-managed height with `!important` so a host theme can't win. */
-    private setFrameHeight;
+    messages?: Record<string, string>;
     /**
-     * Decide whether the host gave the container a DEFINITE (bounded) height — a
-     * fixed block the embed should fill 100% of — versus a content-sized container
-     * that collapses to whatever the iframe measures (full-page usage).
+     * Show an in-chart language switcher offering exactly these languages.
      *
-     * We drive the iframe to two extreme heights within a single synchronous task
-     * and watch whether the container follows: a bounded box barely moves, a
-     * content-sized one grows with the iframe. Because we restore the height before
-     * yielding, the browser only lays out — it never paints the extremes, so there
-     * is no visible flash. Works for px, resolved `%`, and flex (`flex:1;min-h:0`)
-     * heights, and leaves a mere `min-height` floor classified as content-sized so
-     * full-page hosts keep the old viewport-fill behavior.
-     */
-    private detectFillMode;
-    /**
-     * Size the iframe for the current fill verdict, clamped to `minHeight`. In
-     * container mode it fills 100% of the bounded block; in viewport mode its
-     * bottom edge meets the bottom of the viewport (`window.innerHeight - top`).
-     * No-op while pinned fullscreen (the pin fills the viewport itself).
+     * Opt-in and curated on purpose: the chart sits inside someone else's page,
+     * a multilingual host already has its own switcher, and two that can
+     * disagree is worse than either alone. A curated list also beats all 37 — a
+     * German venue wants de/en/pl in the menu, not Welsh. Fewer than two
+     * resolvable entries renders nothing.
      */
-    private applyFill;
-    /** rAF-throttled fill recompute, so a burst of scroll/RO ticks coalesces. */
-    private scheduleFill;
+    languages?: string[];
+    /** ISO 4217 currency for on-map prices (default USD). */
+    currency?: string;
     /**
-     * rAF-throttled re-probe: a host layout change (responsive breakpoint, a block
-     * gaining/losing a definite height) can flip the verdict, so `resize` /
-     * `orientationchange` re-detect and swap the container observer accordingly.
+     * Colorblind-safe rendering: category hues switch to an Okabe-Ito palette
+     * and booked seats render hollow, so state never relies on hue alone.
+     * Toggleable later with setColorblindSafe().
      */
-    private scheduleReprobe;
-    /** Attach/detach the container ResizeObserver to match the current verdict. */
-    private syncContainerObserver;
-    private startFill;
-    private stopFill;
+    colorblindSafe?: boolean;
+    /** Host-authoritative colors for the drawn canvas, separate from native chrome. */
+    mapTheme?: PickerMapTheme;
+    /** Light / dark / follow-the-reader for the DRAWN map — the embed has no
+     *  chrome to re-token, so a mode here means only the canvas ground, and
+     *  `mapTheme` still outranks it. Switchable with {@link SeatingChart.setThemeMode}. */
+    theme?: {
+        mode?: ThemeMode | null;
+    };
+    /** Initial canvas projection.
+     * @deprecated `'isometric'` and `'perspective'` are retired in favour of the
+     * real 3D venue view (`setBuyerView('venue3d')`); they remain accepted for
+     * source compatibility and will be removed in the next major. Use `'flat'`. */
+    initialView?: RendererViewMode;
+    /** Offer the real, lazy-loaded interactive venue view. Default true. */
+    enable3D?: boolean;
+    /** Offer authored/generated view-from-seat inspection. Default true. */
+    enableSeatView?: boolean;
+    /** Optional device-specific ceiling for offering the venue WebGL scene. */
+    max3DSeats?: number;
     /**
-     * Pin the iframe over the host page as a viewport-filling overlay. We save the
-     * iframe's inline style and the document scroll state so `unpinFullscreen`
-     * restores everything exactly. Escape (host-side) also exits.
+     * Built-in seat tooltip on mouse hover (seat · category · price · status).
+     * Rendered inside the widget so every host gets it; default true. Turn off
+     * to draw your own popover from onSeatHover.
      */
-    private pinFullscreen;
-    /** Undo `pinFullscreen`: restore the iframe style + scroll lock. Idempotent. */
-    private unpinFullscreen;
-    private clearTimeoutTimer;
+    seatTooltip?: boolean;
+    /** Internal hosted-runtime control. Defaults true for direct web embeds. */
+    showTestModeIndicator?: boolean;
+    /** Internal hosted-runtime control. Defaults true, subject to white-label entitlement. */
+    showAttribution?: boolean;
     /**
-     * Auto-renewal (proactive + one expiry recovery) is on when the host wired a
-     * relaunch hook and did not opt out. Without the hook there is nothing to call,
-     * so it is a no-op.
+     * Seat hover with everything a popover needs (category label/color, resolved
+     * tier-aware price, live status, currency); null on hover-out. Fires whether
+     * or not the built-in tooltip is enabled.
      */
-    private autoRenewEnabled;
-    private clearRenewTimer;
+    onSeatHover?: (details: SeatHoverDetails | null) => void;
+    onSelectionChange?: (seats: SelectedSeat[]) => void;
+    /** Selection-rule state after each selection change. */
+    onSelectionValidityChange?: (state: PickerSelectionValidity) => void;
+    /** The configured selection rules have just become valid. */
+    onSelectionValid?: (seats: SelectedSeat[]) => void;
+    /** The configured selection rules have just become invalid. */
+    onSelectionInvalid?: (state: PickerSelectionValidity) => void;
+    /** A manual or programmatic selection reached the active maximum. */
+    onSelectionLimit?: (maxSelection: number) => void;
+    onHold?: (result: HoldResult) => void;
+    /** A prior active hold was restored with resumeHold(). */
+    onHoldRestored?: (result: HoldResult) => void;
+    onHoldExpired?: () => void;
+    onGAClick?: (area: GAAreaAvailability) => void;
     /**
-     * Arm the proactive renewal timer from a `ready` message's `expiresAt` (epoch
-     * ms). We relaunch a comfortable lead before expiry so the host can mint a fresh
-     * session and swap `designerUrl` without the user ever seeing the expiry card:
-     *
-     * - normal TTL (≥ 15 min): renew {@link RENEW_LEAD_MS} (~3 min) before expiry;
-     * - short TTL (< 15 min): renew after {@link RENEW_SHORT_TTL_FRACTION} (80%) of
-     *   the remaining life, so the lead can't overshoot the whole session;
-     * - either way, never sooner than {@link RENEW_MIN_DELAY_MS} (30s) after `ready`
-     *   so a burst of `ready` messages can't spin the host.
-     *
-     * Re-armed on every `ready`; cleared on destroy / setDesignerUrl (via re-mount).
-     * A no-op when auto-renewal is off or `expiresAt` is missing/already past — the
-     * expiry-error path recovers a session that has already lapsed.
+     * Mirror of {@link SeatPickerOptions.onGAPrompt}. The low-level chart draws no
+     * quantity UI of its own, so this fires purely as the "the buyer wants to pick
+     * a quantity here" signal, with the same pre-computed `min`/`max`/`tiers` the
+     * full widget would have used; the return value is accepted and ignored.
      */
-    private scheduleRenewal;
-    private ensureContainerPositioned;
-    private restoreContainerStyle;
-    private removeOverlay;
-    private showError;
-    private handleTryAgain;
+    onGAPrompt?: (prompt: GAPromptRequest) => boolean | void;
     /**
-     * Build (or rebuild) the overlay for the given phase. A single overlay element
-     * is reused so we never stack stale skeletons or cards.
+     * The buyer access session lapsed. `refreshed` says whether the provider
+     * already recovered it — false means private inventory is now unavailable and
+     * `onAccessUnavailable` follows. Distinct from `onError` on purpose: this is
+     * never a network failure (guide §10).
      */
-    private renderOverlay;
-    private buildSkeleton;
-    private buildErrorCard;
-    private handleMessage;
-}
-
-/**
- * Buyer-safe ticket-offer availability shared by the canonical picker and the
- * hosted event-page templates.
- *
- * This module intentionally owns the wire parser. A hosted page, iframe, popup
- * and SDK mount must refuse or accept the same payload; duplicating this reader
- * is how one surface eventually prints a price another surface will not charge.
- */
-type SaleState = 'on-sale' | 'low' | 'sold-out' | 'presale' | 'closed';
-interface TicketOfferSummary {
-    /** Legacy ordering fields kept for older page templates and payloads. */
-    index: number;
-    count: number;
-    /** Units currently available at this offer price; null means unlimited. */
-    remaining: number | null;
-    /** Buyer-facing fields added by the offers UX. Absent on older workers. */
-    id?: string;
-    name?: string;
-    categoryKey?: string | null;
-    startsAt?: number | null;
-    endsAt?: number | null;
-}
-interface TicketOfferPrice {
-    categoryKey: string;
-    /** Major units. What a hold on this category is charged right now. */
-    price: number;
-    /** Major units, or null. Printed only when genuinely higher. */
-    previousPrice: number | null;
-    /** Offer provenance for the price row. Absent on older workers. */
-    offerId?: string;
-    offerName?: string;
-    remaining?: number | null;
-    startsAt?: number | null;
-    endsAt?: number | null;
-}
-interface ChannelPriceOverride {
-    categoryKey: string;
-    tierId: string | null;
-    price: number;
-}
-/** Pricing configuration projected only for the private channels in this grant. */
-interface BuyerChannelPricing {
-    assignmentVersion: number;
-    channels: Array<{
-        channelId: string;
-        pricingVersion: number;
-        priceOverrides: ChannelPriceOverride[];
-    }>;
-    objects: Array<{
-        label: string;
-        channelId: string;
-    }>;
-}
-interface TicketOfferAvailability {
-    state: SaleState;
-    /** Currently advertised offer price, in minor units. */
-    fromPrice: number | null;
-    previousPrice: number | null;
-    currency: string | null;
-    /** The highest-priority active buy offer, when one exists. */
-    release: TicketOfferSummary | null;
-    /** The next scheduled price offer. It does not close ordinary ticket sales. */
-    upcoming: TicketOfferSummary | null;
-    /** Server-resolved active offer prices by category, in major units. */
-    prices: TicketOfferPrice[];
-    channelPricing: BuyerChannelPricing | null;
-}
-/** Parse a public offer payload without repairing a half-understood price. */
-declare function parseTicketOfferAvailability(body: unknown): TicketOfferAvailability | null;
-/** Translate the server-resolved category map into SeatPicker pricing. */
-declare function ticketOfferPrices(availability: TicketOfferAvailability | null): Record<string, number>;
-
-/**
- * pickerTypes — the SeatPicker public option/theme/pricing contract, plus the
- * two internal shapes (`SectionLike`, `PriceBand`) the picker reads off a
- * ChartDoc.
- *
- * Split out of SeatPicker.ts verbatim; these declarations are the widget's
- * published API surface, so SeatPicker.ts re-exports every public name from
- * here and `@seatlayer/js`'s entry (src/index.ts) is untouched. Types only —
- * nothing in this file emits a byte of runtime JavaScript.
- */
-
-/**
- * Stable checkout-handoff contract (P4). Passed as the THIRD argument to
- * `onCheckout(hold, seats, handoff)` — additive, so the legacy `(hold, seats)`
- * shape used by DesiPass web-v2 (SDK 0.7.3+) is untouched. This is the object to
- * build your order against: it is self-contained (holdId, expiry, currency, and
- * per-line tier + price) and never changes shape across minor releases.
- */
-interface CheckoutLineItem {
-    /** Seat label (or GA synthetic-unit label) — the stable booking identity. */
-    label: string;
+    onAccessExpired?: (event: BuyerAccessExpiredEvent) => void;
     /**
-     * Buyer-facing name (the designer's `displayLabel` override), when set.
-     * Show this in YOUR order summary; `label` stays the booking identity you
-     * pass to the book call. Absent = no override, fall back to `label`.
+     * Private inventory is unavailable and refreshing will not fix it — revoked,
+     * paused, wrong origin/event/mode, or the provider failed. Carries a reason,
+     * never a channel name, id, colour or count.
      */
-    displayLabel?: string;
+    onAccessUnavailable?: (event: BuyerAccessUnavailableEvent) => void;
     /**
-     * Buyer-facing type word override (seats.io "Displayed type", e.g. "Table",
-     * "Bench", "Box"), when the designer set one. Absent = the default word.
+     * Selected-but-unheld units stopped being selectable — someone else took
+     * them, or an allocation change moved them out of this buyer's scope. The
+     * widget has already dropped them from the selection.
      */
-    displayType?: string;
-    /** Chart object id (row/booth/GA area) the unit belongs to. */
-    objectId: string;
-    objectType: 'seat' | 'booth' | 'ga' | 'table';
-    categoryKey: string;
-    /** Chosen ticket tier id (Adult/Child/…), or null when the category has no tiers. */
-    tierId: string | null;
-    /** Unit price in MAJOR currency units (e.g. 45 = 45.00). Server-authoritative. */
-    unitPrice: number;
-    /** ISO-4217, resolved server-side (per-event override → org → USD). */
-    currency: string;
-    quantity: number;
-}
-interface CheckoutHandoff {
-    /** Server hold id — pass this to YOUR book call. */
-    holdId: string;
-    /** Epoch ms the hold expires (after any extensions). */
-    expiresAt: number;
-    /** ISO-4217 currency for the whole order. */
-    currency: string;
-    /** Priced line items (tier + unit price + currency), server-authoritative. */
-    lineItems: CheckoutLineItem[];
-    /** Convenience total in major units (Σ unitPrice × quantity). */
-    total: number;
-}
-/** Host-authoritative pricing — see {@link SeatPickerOptions.pricing}. */
-interface SeatPickerPricing {
-    /** Unit prices by category key: a flat number, or `{ base, tiers: { tierId: price } }`. */
-    prices?: Record<string, number | {
-        base?: number;
-        tiers?: Record<string, number>;
-    }>;
-    /** Custom money renderer (e.g. `(n) => n + '€'`). Defaults to Intl currency formatting. */
-    formatter?: (amount: number, currency: string) => string;
-}
-/** Optional constraints for the server-authoritative best-available pick. */
-interface SeatPickerBestAvailableOptions {
-    /** Prefer a contiguous premium block, falling back to the best overall block. */
-    preferPremium?: boolean;
-    /** Restrict the search to one configured chart zone. */
-    zoneId?: string;
-}
-/** Buyer-facing surface shown by the full picker widget. */
-type SeatPickerBuyerView = 'map' | 'venue3d';
-/** Optional camera intent when switching the buyer-facing surface. */
-interface SeatPickerBuyerViewOptions {
-    /** Enter (or remain in) 3D and fly the camera to this seat id. */
-    flyToSeatId?: string;
-    /** When already in 3D, return the camera to the venue overview. */
-    resetView?: boolean;
-}
-/** Host theme overrides — any subset; unset keys fall back to the org's chart theme, then defaults. */
-interface SeatPickerTheme {
+    onSelectedObjectUnavailable?: (event: SelectedObjectUnavailableEvent) => void;
+    onError?: (err: unknown) => void;
     /**
-     * Light, dark, or follow the reader's own `prefers-color-scheme`.
+     * What the BUYER sees when the chart cannot load.
      *
-     * OPT-IN. Omit it and the widget renders exactly what it always did: the
-     * chart's authored ground, the organizer's colours, your own overrides. Set
-     * it and the built-in token set for that side takes the GROUND roles —
-     * background, surface, ink, muted ink, hairlines, and the drawn map's own
-     * canvas — while the organizer's accent, font, radius and logo, and every
-     * colour you state explicitly below, stay exactly as they are.
+     * `'message'` (the default) renders a plain, styleable notice with a Try
+     * again button. This used to be silent unconditionally: `render()` returned
+     * with an EMPTY mounted div and only `onError` fired, so a host that had not
+     * wired `onError` — or had wired it to a logger — showed buyers a blank
+     * rectangle where the seat map belongs, on the host's own domain, which
+     * reads as a broken website rather than a temporary fault. `SeatPicker` has
+     * always failed loud with a retry; this is the embed class catching up.
      *
-     * `'auto'` is re-read live: a buyer who flips their phone into dark mode
-     * mid-purchase keeps their seats and their hold.
+     * `'none'` restores the silent behaviour for hosts that render their own
+     * failure UI from `onError`.
      */
-    mode?: ThemeMode;
-    /** Brand accent (CTA, active chips, hold pill). */
-    accent?: string;
-    /** Ink on the accent (button labels). */
-    accentInk?: string;
-    /** Widget background. */
-    background?: string;
-    /** Panel/card surface color. */
-    surface?: string;
-    /** Primary text color. */
-    text?: string;
-    /** Secondary text color. */
-    muted?: string;
-    /** Hairline/border color. */
-    line?: string;
-    /** Font stack for all widget chrome. */
-    fontFamily?: string;
-    /** Corner radius base (px). */
-    radius?: number;
-    /** Header logo URL (falls back to the org logo from the chart theme, then a monogram). */
-    logoUrl?: string;
-    /** Brand/event fallback name for the monogram. */
-    brandName?: string;
+    errorDisplay?: 'message' | 'none';
+    /** Which pieces of the IMMERSIVE scene's own chrome this embed draws. The
+     *  2D chrome each has its own option above; the 3D caption, seat stepper and
+     *  camera dock come from inside the lazy venue chunk, where an embedding
+     *  host had no way to reach them — so a native shell that already draws all
+     *  three drew them twice. Absent or `true` = drawn, exactly as before. */
+    chrome?: {
+        view3dCaption?: boolean;
+        view3dSeatStepper?: boolean;
+        view3dControlDock?: boolean;
+    };
+    /**
+     * Multi-floor charts only: fires when the buyer taps a deck in the stacked
+     * 3D view, after the picker switches to that floor — lets the host page sync
+     * its own floor UI (tabs, labels) with the map.
+     */
+    onDeckTap?: (floorId: string) => void;
+    /** Big-venue section focus state for host-owned navigation chrome. */
+    onSectionFocus?: (summary: SectionSummary | null) => void;
+    /** Availability changed after a live frame or explicit refresh. */
+    onStatusChange?: () => void;
+    /** The server closed sales for this event. */
+    onSalesClosed?: () => void;
+    /** A programmatic/native map-control action changed serializable map state. */
+    onMapStateChange?: () => void;
+    /** rAF-coalesced camera-frame signal for in-page overlays; not native state. */
+    onViewChange?: () => void;
+    /** Real buyer-view transitions and 3D camera targets. */
+    onBuyerViewChange?: (state: {
+        view: SeatingChartBuyerView;
+        seatId?: string;
+    }) => void;
     /**
-     * The DRAWN MAP, which the tokens above deliberately do not reach.
-     *
-     * Everything else on this interface is CSS: it re-inks panels, buttons and
-     * the sidebar. The seat map is a canvas, painted from the chart document's
-     * own `ChartTheme`, so a host could re-ink the whole widget and still be
-     * looking at somebody else's dark venue in the middle of it (which is exactly
-     * what SeatLayer's own light event-page palettes did, found 2026-08-07).
-     *
-     * Nested rather than flattened because `background` already means the
-     * WIDGET's background here and the canvas ground is a different surface —
-     * two things one word cannot carry.
-     *
-     * Set it only when you can vouch for the result: these colours are drawn
-     * behind and beside live seat statuses (held, sold, selected), and the map is
-     * the one part of this widget a buyer has to be able to read.
+     * Non-blocking, localized selection advice — currently the orphan-seat hint
+     * (the selection would strand a single free seat between taken neighbors).
+     * `null` clears it. Purely informational; nothing is ever prevented.
      */
-    map?: PickerMapTheme;
+    onHint?: (message: string | null) => void;
 }
-interface SeatPickerOptions {
-    /** CSS selector or element to mount into. Omit when using SeatPicker.open(). */
-    container?: string | HTMLElement;
-    /** Event key, e.g. `ev_xxx`. */
-    event: string;
-    /** API origin. Defaults to https://api.seatlayer.io. */
-    apiBase?: string;
+declare class SeatingChart {
+    private readonly opts;
+    private readonly controller;
+    /** Publishable key used only by the public-only direct bootstrap path. */
+    readonly publicKey?: string;
+    private mount;
+    private hostEl;
     /**
-     * Custom data transport. Defaults to the CORS-trivial PubApi against
-     * `apiBase`. Inject to run the widget against another backend adapter (the
-     * SeatLayer dashboard's own transport) or a fully local mock (demos).
+     * Native hosts can render a Flutter/Swift/Kotlin decision surface above this
+     * DOM tree. UIKit platform views still participate in hit testing beneath a
+     * composited native overlay, so the runtime must be able to make its own DOM
+     * inert rather than relying on the host's visual stacking alone.
      */
-    transport?: PickerTransport;
+    private interactionEnabled_;
+    /** The organizer's language for this event, learned when the chart resolves. */
+    private eventLocale;
+    private rendered;
+    private mode_;
+    private eventInfo;
+    private maxSelection_;
+    private colorblindSafe_;
+    private readonly hostSurface;
+    private categoryFilter_;
+    private accessibilityFilter_;
+    private hideLimitedView_;
+    private focusedSection_;
+    /** Last rung already exposed to native chrome; raw camera frames stay in-canvas. */
+    private lastReportedViewRung_;
+    private accessState_;
+    private tipEl;
+    private tipPos;
+    private onTipMove;
+    /** Null for the ordinary public chart — the tokenless path is untouched. */
+    private readonly access;
+    private readonly api;
+    private readonly apiBase;
+    private readonly buyerAssetUrls;
+    private readonly immersive;
+    private realtime;
+    constructor(options: SeatingChartOptions);
     /**
-     * Publishable account key (`pk_live_…` / `pk_test_…`) for a public
-     * Platform/SDK Event. With no explicit buyer-access token/provider, the SDK
-     * uses it to bootstrap one origin-bound, Public-sale-only session directly
-     * from SeatLayer and receives chart + inventory in the same request.
-     *
-     * This is not buyer identity and cannot request private channels. An explicit
-     * `buyerAccessTokenProvider` or `buyerAccessToken` below always takes
-     * precedence for login, presale, partner or other scoped inventory.
+     * Camera x/y/scale is renderer-local and deliberately absent from the native
+     * picker snapshot. Keep pan and pinch frames on the canvas; only a semantic
+     * rung transition needs to wake native chrome.
      */
-    publicKey?: string;
+    private handleViewChange;
+    /** Record the current rung before publishing an explicit state mutation. */
+    private notifyMapStateChange;
+    /** Fetch the chart, mount the renderer, seed statuses and go live. Idempotent. */
+    render(): Promise<this>;
     /**
-     * Buyer access session provider — the recommended way to show private channel
-     * inventory (Sales Channels guide §6).
-     *
-     * Called with a `reason` whenever the widget needs a bearer: first
-     * acquisition, a near/actual expiry, a 401 `buyer_access_expired`, a realtime
-     * reconnect, or `refreshAccess()`. It should POST to YOUR backend, which
-     * mints the session with your secret key and returns `{ token, expiresAt }`.
-     *
-     * The token lives in memory for the widget's lifetime and nowhere else: never
-     * in storage, never in a URL, never in a log or an error message. Refresh
-     * returns the same or a narrower scope; the widget never widens to Public
-     * sale on its own, and a failed refresh stops the scoped operation rather
-     * than retrying it anonymously. Any held seats stay held — a hold is
-     * relinquished by its own opaque capability, not by channel access, so
-     * losing access never strands inventory (guide §9).
-     *
-     * Ignored when a custom `transport` is supplied: that host owns its own
-     * credentials.
+     * Attribution badge pinned to the embed's bottom-right, linking to
+     * seatlayer.io. Rendered as an absolutely-positioned overlay with
+     * self-contained inline styles — the SDK embed ships no widget CSS, and an
+     * overlay keeps it out of the layout flow so it never disturbs the SDK v0.22
+     * fill-height resize contract. Mirrors the full widget's mark + wordmark and
+     * reuses the `picker.poweredBy` i18n string.
      */
-    buyerAccessTokenProvider?: BuyerAccessTokenProvider;
+    private buildBadge;
+    private placeTooltip;
+    private updateTooltip;
     /**
-     * One-shot escape hatch for hosts that already own the session lifecycle.
-     * Cannot be renewed — when it lapses the widget reports `onAccessExpired`
-     * and then `onAccessUnavailable`. Prefer `buyerAccessTokenProvider`.
+     * Whether the SERVED event is a live or a test event (`sk_test_` keys create
+     * test events, which never book real inventory). `null` before render()
+     * resolves — the mode comes from the server with the chart, not from options.
+     *
+     * The widget already surfaces this visually with the test-mode ribbon; this
+     * getter is for hosts that draw their own chrome — notably a native WebView
+     * wrapper, which must be able to tell an integrator that the build they are
+     * about to ship is pointed at a test event.
      */
-    buyerAccessToken?: string | BuyerAccessToken;
-    /** Max seats selectable at once (default 10). */
-    maxSelection?: number;
-    /** Object ids or public labels selected after live availability is loaded. */
-    selectedObjects?: string[];
-    /** Object ids or public labels the buyer may select. Omit for all free objects. */
-    selectableObjects?: string[] | null;
-    /** Require exactly this many total seated/table/GA guest units before checkout. */
-    numberOfPlacesToSelect?: number;
-    /** Optional sale guards evaluated after every change and enforced before a
-     * hold: minimum quantity, consecutive seats, and/or no stranded singles. */
-    selectionValidators?: PickerSelectionValidator[];
     /**
-     * BCP 47 language for the widget UI. 37 languages ship; omit this and each
-     * buyer gets their own `navigator.languages`, falling back to English.
-     * Read once at render — there is no way to change it on a live chart.
+     * The opt-in language switcher, offering exactly the languages the host
+     * named. Absent unless `languages` lists at least two — a menu with one
+     * entry is furniture, and an unrequested one duplicates the switcher a
+     * multilingual host site already has.
+     *
+     * Each language names itself (`LOCALE_NAMES`): a reader scanning for their
+     * own language finds "Deutsch", never "German". An English list is
+     * unreadable to exactly the people who need it.
      */
-    locale?: string;
-    /** Per-key string overrides layered over the active locale. */
-    messages?: Record<string, string>;
+    private buildLanguageSwitcher;
     /**
-     * Show an in-picker language switcher offering exactly these languages.
+     * Change the language of a LIVE chart, keeping the buyer's selection.
      *
-     * Opt-in and curated on purpose. Omit it and there is no control: the widget
-     * sits inside someone else's page, and a multilingual host site already has
-     * its own switcher — two that can disagree is worse than either alone. A
-     * curated list also beats offering all 37: a German venue wants de/en/pl in
-     * the menu, not Welsh.
+     * `locale` is otherwise read once at render, which is fine for a page that
+     * knows its language up front and useless for one with a language switcher.
+     * The competing embed API can only `rerender()`, and that clears the
+     * selection — losing someone's seats because they changed language is not an
+     * acceptable trade, so this rebuilds the map through `refreshMapCopy()`,
+     * which restores the selection on the far side.
      *
-     * Switching keeps the buyer's selection; it does not re-render the chart.
+     * Returns the locale that actually became active: an unsupported or
+     * not-yet-translated tag resolves to English rather than throwing, exactly as
+     * it does at first render.
      */
-    languages?: string[];
-    /** ISO 4217 currency fallback (the org/event currency on the chart wins). */
-    currency?: string;
-    /** Colorblind-safe rendering (Okabe-Ito palette, hollow booked seats). */
-    colorblindSafe?: boolean;
+    setLocale(next: string | null | undefined): Promise<string>;
+    getMode(): 'live' | 'test' | null;
+    /** Atomic, token-free display state for native-owned picker chrome. */
+    getPickerState(): SeatingChartPickerState;
+    getCategoryAvailability(): Record<string, number>;
+    getBestAvailableZones(): Array<{
+        id: string;
+        label: string;
+    }>;
+    getActiveFloorId(): string | null;
+    getRung(): LodRung;
+    getFocusedSection(): string | null;
+    focusSection(sectionId: string): void;
+    overview(): void;
+    setRung(rung: LodRung): void;
+    setCategoryFilter(categoryKeys: string[] | null, focus?: boolean): void;
+    setAccessibilityFilter(types: string[] | null): void;
+    setCommercialLimitedFilter(on: boolean): void;
+    /** Current selection with prices resolved from the chart categories. */
+    getSelection(): SelectedSeat[];
+    /** Select free objects by engine id or public label. Returns newly selected objects. */
+    selectObjects(objects: string[]): SelectedSeat[];
+    /** Deselect objects by engine id or public label. */
+    deselectObjects(objects: string[]): void;
+    /** Clear every unheld selection. */
+    clearSelection(): void;
+    /** Select every selectable object in the named categories. */
+    selectCategories(categoryKeys: string[]): SelectedSeat[];
+    /** Deselect every selected object in the named categories. */
+    deselectCategories(categoryKeys: string[]): void;
+    /** Replace the buyer-selectable object allow-list without remounting. */
+    setSelectableObjects(objects: string[] | null): void;
+    /** Change the selection cap without remounting. */
+    setMaxSelection(maxSelection: number): void;
+    /** Current selection-rule validity, or null when no rules were configured. */
+    getSelectionValidity(): PickerSelectionValidity | null;
+    /** Hold the current selection. Resolves the hold, or null on a 409 conflict. */
+    hold(options?: {
+        ttlMs?: number;
+    }): Promise<HoldResult | null>;
+    /**
+     * @internal Like {@link hold} but RE-THROWS the structured API error (409
+     * `reason`/`code` + `conflicts`) instead of swallowing it into `onError` +
+     * `null`. The native WebView host adapter needs the throw so it can answer the
+     * originating command with a correlated error carrying the SPECIFIC reason
+     * (`sold_out` vs `not_enough_together`); the public method above keeps the
+     * catch-and-onError contract that direct web consumers rely on. Not a stable
+     * part of the embed API.
+     */
+    holdOrThrow(options?: {
+        ttlMs?: number;
+    }): Promise<HoldResult | null>;
+    /** Restore an active hold by its opaque id without extending its expiry. */
+    resumeHold(holdId: string): Promise<HoldResult | null>;
+    /** @internal Throwing variant of {@link resumeHold} for the native host adapter. See {@link holdOrThrow}. */
+    resumeHoldOrThrow(holdId: string): Promise<HoldResult | null>;
+    /**
+     * Push the OPEN hold's expiry out ("need more time?"). Resolves the refreshed
+     * hold, or `null` when there is nothing held or the server refused (the hold
+     * is gone, already expired, or at its renewal cap) — refusal is a normal
+     * outcome, not an error, so the host decides the copy. The client-side expiry
+     * timer is re-armed to match, so `onHoldExpired` won't fire early.
+     */
+    extendHold(ttlMs?: number): Promise<HoldResult | null>;
+    /** Current active hold known to this chart, if any. */
+    getCurrentHold(): HoldResult | null;
+    getGAAreas(): GAAreaAvailability[];
+    holdGA(areaId: string, qty: number, options?: {
+        tierId?: string | null;
+        ttlMs?: number;
+    }): Promise<HoldResult | null>;
+    /** @internal Throwing variant of {@link holdGA} for the native host adapter. See {@link holdOrThrow}. */
+    holdGAOrThrow(areaId: string, qty: number, options?: {
+        tierId?: string | null;
+        ttlMs?: number;
+    }): Promise<HoldResult | null>;
     /**
-     * How a big chart's seats arrive: 'progressive' (default) shows the venue's
-     * sections as soon as the chart lands and fills the seats in a section at a
-     * time, nearest the viewport first; 'plain' builds the whole scene in one
-     * step. Small charts are built in one step either way.
+     * Ask the server for the `qty` best free seats and hold them atomically.
+     * `options.ttlMs` sets the checkout window exactly like {@link hold}; omit it
+     * and the server falls back to the event setting, then its own default.
      */
-    loadingReveal?: 'progressive' | 'plain';
-    /** Initial map projection. Buyers now toggle **Map (flat 2D) + 3D** only; the
-     * legacy `perspective` (2.5D) value is still ACCEPTED for source compatibility
-     * but is deprecated — it is coerced to `flat` with a one-time console warning.
-     * The 3D venue view is entered from the Map/3D control, not this option. */
-    initialView?: RendererViewMode;
-    /**
-     * Offer the interactive 3D venue view (Map | 3D toggle + a "See it in 3D"
-     * action on the seat-confirm card). Default true. The 3D button is shown only
-     * when this is not false AND the browser exposes WebGL2; there are ZERO GL
-     * bytes on the wire until the buyer actually opens 3D (the OGL chunk is
-     * dynamically imported on first use). Set false for embed hosts that must
-     * stay strictly 2D. */
-    enable3D?: boolean;
+    bestAvailable(qty: number, categoryKey?: string, options?: {
+        zoneId?: string;
+        preferPremium?: boolean;
+        ttlMs?: number;
+    }): Promise<BestAvailableResult | null>;
+    /** @internal Throwing variant of {@link bestAvailable} for the native host adapter. See {@link holdOrThrow}. */
+    bestAvailableOrThrow(qty: number, categoryKey?: string, options?: {
+        zoneId?: string;
+        preferPremium?: boolean;
+        ttlMs?: number;
+    }): Promise<BestAvailableResult | null>;
     /**
-     * Seat-count ceiling above which 3D is not offered. Default: 60,000 seats on
-     * desktop, reduced to 30,000 on a device that reports itself as small/low-core.
-     *
-     * The 53,018-seat evidence is desktop-only; that scale remains unmeasured on
-     * phones, which is why the small-device default stays conservative. The 3D
-     * scene holds every seat resident until a streaming rung exists. */
-    max3DSeats?: number;
+     * Choose a ticket tier for a selected seat (e.g. Adult → Child). The seat's
+     * available `tiers` are on each `SelectedSeat` from `getSelection()` /
+     * `onSelectionChange`. Re-emits the selection with the new tier + price, and
+     * the tier rides along in the next `hold()` / `onHold` per seat. `tierId=null`
+     * reverts to the default tier.
+     */
+    setSeatTier(seatId: string, tierId: string | null): void;
+    /** Confirm/update an unheld variable table's guest quantity locally. */
+    setTableQuantity(label: string, quantity: number): boolean;
     /**
-     * Fires when the buyer enters/leaves 3D or targets a seat there. Hosts can
-     * mirror this small, non-sensitive state into a shareable URL.
+     * Atomically replace an active variable-table hold with a new guest count.
+     * Returns null for an inapplicable/invalid quantity or a refused replacement.
      */
-    onBuyerViewChange?: (state: {
-        view: SeatPickerBuyerView;
-        seatId?: string;
-    }) => void;
+    replaceTableQuantity(label: string, quantity: number, ttlMs?: number): Promise<HoldResult | null>;
+    /** @internal Throwing variant used by the correlated native bridge. */
+    replaceTableQuantityOrThrow(label: string, quantity: number, ttlMs?: number): Promise<HoldResult | null>;
     /**
-     * Optional analytics sink for the widget's journey and performance events.
-     * Emits `chart_rendered` once per successful load with total time, step
-     * timings and anonymous chart-size counts, plus the 3D venue-view journey
-     * (`3d_opened`, `3d_orbit_engaged`, `3d_seat_picked`,
-     * `3d_cinematic_played`/`_skipped`/`_cancelled`, panorama outcomes, and WebGL
-     * context loss/recovery)
-     * with `{ surface: 'buyer' }` merged into the props. A throwing sink never
-     * breaks the widget. Route it to your product analytics (e.g. PostHog). */
-    onAnalytics?: (event: string, props: Record<string, unknown>) => void;
+     * Floors of a multi-floor chart — `[{ id, name }]` (single-floor charts
+     * return one entry; empty before render()). Pair with setFloor() to build a
+     * host-side floor switcher.
+     */
+    getFloors(): {
+        id: string;
+        name: string;
+    }[];
+    /** Switch the shown floor (2D). Warns + no-ops on single-floor charts. */
+    setFloor(floorId: string): void;
+    /** Toggle colorblind-safe rendering at runtime (see options.colorblindSafe). */
+    setColorblindSafe(on: boolean): void;
+    /** Switch the 2D canvas projection.
+     * @deprecated `'isometric'` and `'perspective'` are retired in favour of the
+     * real 3D venue view (`setBuyerView('venue3d')`); accepted for source
+     * compatibility until the next major. */
+    setViewMode(mode: RendererViewMode): void;
+    /** Current canvas projection. */
+    getViewMode(): RendererViewMode;
+    /** Zoom in one step (same increment as the wheel/pinch gesture). */
+    zoomIn(): void;
+    /** Zoom out one step. */
+    zoomOut(): void;
+    /** Reset the camera so the whole chart fits the container. */
+    zoomToFit(): void;
     /**
-     * Every seat of a progressively revealed chart is now built and painted.
+     * Light / dark / follow-the-reader, applied to a LIVE map.
      *
-     * `render()` resolves with the section shells and the nearest seats — the
-     * rest arrive in idle slices. A host that needs "the whole venue is on
-     * screen" waits for this rather than for `render()`. Fires exactly once per
-     * chart, and never for a chart small enough to build in one step (there is
-     * nothing to wait for: `render()` already was that moment).
+     * This is a repaint, not a remount. It re-inks the canvas through the
+     * controller's in-place rebuild, which keeps the buyer's selection, the
+     * section they had opened and the exact camera pose — a native shell
+     * flipping the OS appearance must not cost the buyer their seats or their
+     * place in the venue. `null` hands the ground back to the chart's own
+     * colours; an explicit `mapTheme` still outranks any mode.
      */
-    onSeatsRevealed?: () => void;
+    /** A repaint, not a remount: the buyer keeps their selection, their focused
+     *  section and their camera. See ./seatingChartHostSurface. */
+    setThemeMode(mode: ThemeMode | null, options?: {
+        mapTheme?: PickerMapTheme | null;
+    }): void;
+    /** The mode the host asked for — `'auto'`, not what `auto` resolved to. */
+    getThemeMode(): ThemeMode | null;
+    /** Report the chrome the HOST draws over the map, in CSS px, so framing
+     *  aims at what the buyer can see. See ./seatingChartHostSurface. */
+    setViewportInsets(insets: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    } | null): void;
+    /** The insets in force; all zero when the host reported none. */
+    getViewportInsets(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Enter or leave the same real lazy-loaded venue scene as SeatPicker. */
+    setBuyerView(view: SeatingChartBuyerView, options?: {
+        flyToSeatId?: string;
+        resetView?: boolean;
+    }): Promise<void>;
+    getBuyerView(): SeatingChartBuyerView;
+    /** Open an authored or chart-derived 360° view for one physical seat. */
+    openSeatView(seatId: string): Promise<void>;
+    /** Explicit Rotate / Move control for native and custom picker chrome. */
+    setVenue3DNavigationMode(mode: SeatingChartNavigationMode): void;
     /**
-     * Optional organiser-defined campaign/referral label (max 120 characters).
-     * On the public SeatLayer transport it is frozen onto the hold, then copied
-     * to the Managed order, organiser reporting and booking webhook. It grants no
-     * inventory access and is ignored by host-supplied transports.
+     * Enable or suppress all buyer input inside this chart without unmounting it.
+     *
+     * Native SDKs use this while a native confirmation, quantity prompt, loading
+     * surface or error surface owns the chart area. Disabling input in the DOM is
+     * intentional: an iOS WKWebView can receive the same physical tap beneath a
+     * Flutter overlay even when the Flutter widget is wrapped in IgnorePointer.
+     * Programmatic bridge commands continue to work, so a prompt can still open
+     * view-from-seat or 3D and then re-enable interaction after the handoff.
      */
-    referral?: string;
+    setInteractionEnabled(enabled: boolean): void;
+    private applyInteractionState;
+    /** Release the current hold (if any). No-op when nothing is held. */
+    release(): Promise<void>;
+    /** Release selected labels from the current hold while keeping the remainder. */
+    releaseLabels(labels: string[]): Promise<boolean>;
+    /** Tear everything down: close the socket, stop timers, drop the canvas. */
     /**
-     * Hide the "Powered by SeatLayer" attribution badge in the side panel foot.
-     * The chart theme's own `hideBadge` flag (paid orgs) also hides it — the badge
-     * is shown only when BOTH this option and the theme flag are unset/false.
+     * Realtime for an access-scoped chart.
+     *
+     * A tokenless chart never gets here: `access` is null, `PubApi.socketUrl()`
+     * returns the URL it always has, and PickerController keeps its own socket
+     * and its own legacy frames. Nothing about the public path changes.
      */
-    hideBadge?: boolean;
+    private startRealtime;
+    /** Re-read live inventory without remounting or dropping buyer state. */
+    refreshAvailability(): Promise<void>;
     /**
-     * Hide the picker's event identity (logo, event name and venue/date metadata)
-     * when the host surface already presents the same event heading. The hold
-     * timer, sales status and modal close controls remain available. The identity
-     * is restored automatically while the picker is full screen so it never
-     * loses context on a small device or an expanded map. Default false.
-     *
-     * A mounted host can update this through `setEventDetailsHidden()` when its
-     * own event chrome arrives asynchronously.
+     * Re-acquire the buyer access session — call after your app has re-authorized
+     * the buyer (a revoked session cannot be recovered any other way). Resolves
+     * true when a fresh bearer is held; the realtime feed restarts with it.
      */
-    hideEventDetails?: boolean;
+    refreshAccess(): Promise<boolean>;
     /**
-     * Start the wide-layout ticket panel collapsed so the map owns the full
-     * width (map-first hosts, small embeds). The buyer reopens it with the
-     * "Tickets" pill beside Map|3D, and it opens itself the moment a seat lands
-     * in the cart — a collapsed panel must never hide a checkout. Narrow
-     * layouts ignore this (the bottom sheet is already the collapse). A mounted
-     * host can drive it later through `setPanelCollapsed()`. Default false.
+     * The visible failure state. Deliberately inline-styled and dependency-free:
+     * this renders on a stranger's website, where our stylesheet may not have
+     * loaded (the chart fetch just failed) and where inheriting the host's own
+     * styles is likelier to produce something unreadable than something on-brand.
      */
-    panelCollapsed?: boolean;
-    /** Host theme overrides — see SeatPickerTheme. */
-    theme?: SeatPickerTheme;
+    private showLoadFailure;
+    destroy(): void;
+}
+
+/**
+ * seatingChartBinding — the single source of truth the framework wrappers bind
+ * against.
+ *
+ * `@seatlayer/react`, `@seatlayer/vue` and `@seatlayer/angular` are supposed to
+ * be thin: mount a `SeatingChart`, forward the props, forward the callbacks,
+ * expose the imperative handle. In practice each of them hand-wrote all three
+ * lists, and they drifted — React grew `initialView` and `errorDisplay` props
+ * that Vue and Angular never got, and nothing in any build caught it, because a
+ * missing prop in a hand-written list is not a type error anywhere.
+ *
+ * So the lists live here, next to the class they describe, and the wrappers
+ * iterate them. Adding a method to `SeatingChart` that buyers should be able to
+ * call now means adding one entry to {@link SEATING_CHART_HANDLE_METHODS}; every
+ * wrapper picks it up, and the wrapper tests fail until each one exposes it.
+ *
+ * Types only against `SeatingChart` — this module imports no runtime value from
+ * it, so it costs a host nothing but the two arrays and the binder below.
+ */
+
+/**
+ * Imperative handle exposed by every wrapper — call these to drive the picker
+ * from your app.
+ *
+ * Angular is the one exception to the naming: its component surfaces `hold` as
+ * `holdSelection`, because `hold` is already taken by its `@Output()` event.
+ */
+interface SeatingChartHandle {
+    /** Hold the current selection. Resolves the hold, or `null` on a 409 conflict. */
+    hold(options?: {
+        ttlMs?: number;
+    }): Promise<HoldResult | null>;
+    /** Restore an active hold by its opaque id. */
+    resumeHold(holdId: string): Promise<HoldResult | null>;
+    /** Current active hold known to the chart. */
+    getCurrentHold(): HoldResult | null;
+    /** GA areas with live remaining capacity. */
+    getGAAreas(): GAAreaAvailability[];
+    /** Atomically hold a quantity from one GA area. */
+    holdGA(areaId: string, qty: number, options?: {
+        tierId?: string | null;
+        ttlMs?: number;
+    }): Promise<HoldResult | null>;
+    /** Ask the server for the `qty` best free seats and hold them atomically. */
+    bestAvailable(qty: number, categoryKey?: string): Promise<BestAvailableResult | null>;
+    /** Release the current hold (if any). */
+    release(): Promise<void>;
+    /** Release some held labels while keeping the remainder active. */
+    releaseLabels(labels: string[]): Promise<boolean>;
+    /** The current selection, with prices resolved from the chart categories. */
+    getSelection(): SelectedSeat[];
+    /** Select free objects by engine id or public label. */
+    selectObjects(objects: string[]): SelectedSeat[];
+    /** Deselect objects by engine id or public label. */
+    deselectObjects(objects: string[]): void;
+    /** Clear every unheld selection. */
+    clearSelection(): void;
+    /** Select every selectable object in the named categories. */
+    selectCategories(categoryKeys: string[]): SelectedSeat[];
+    /** Deselect every selected object in the named categories. */
+    deselectCategories(categoryKeys: string[]): void;
+    /** Replace the buyer-selectable object allow-list without rebuilding. */
+    setSelectableObjects(objects: string[] | null): void;
+    /** Change the selection cap without rebuilding. */
+    setMaxSelection(maxSelection: number): void;
+    /** Current exact-count validity, or null when no exact count was configured. */
+    getSelectionValidity(): PickerSelectionValidity | null;
     /**
-     * Host-authoritative pricing. When your shop charges different prices than
-     * the chart's stored category prices, pass them here so the buyer sees the
-     * price they will actually pay — on the map tooltip, confirm popover, price
-     * panel, tray, totals, and in the checkout handoff's line items. Keyed by
-     * category key; per-tier overrides nest under `tiers`. Unlisted categories
-     * fall back to the chart price.
+     * Choose a ticket tier for a selected seat (e.g. Adult → Child). Available
+     * `tiers` are on each `SelectedSeat`; `tierId=null` reverts to the default.
      */
-    pricing?: SeatPickerPricing;
+    setSeatTier(seatId: string, tierId: string | null): void;
     /**
-     * Fires when the server-resolved active offer changes. Hosted event pages use
-     * this to keep their headline, sticky bar and the canonical picker on the
-     * same live fact. The picker remains fully functional when it is omitted.
+     * Floors of a multi-floor chart — `[{ id, name }]` (single-floor charts
+     * return one entry; empty before render()). Pair with setFloor().
      */
-    onOfferAvailabilityChange?: (availability: TicketOfferAvailability | null) => void;
-    /** Hold TTL in ms passed to hold(); server clamps to its own limits. */
-    holdTtlMs?: number;
+    getFloors(): {
+        id: string;
+        name: string;
+    }[];
+    /** Switch the shown floor (2D). Warns + no-ops on single-floor charts. */
+    setFloor(floorId: string): void;
+    /** Toggle colorblind-safe rendering at runtime (see the `colorblindSafe` prop). */
+    setColorblindSafe(on: boolean): void;
+    /** Zoom in one step (same increment as the wheel/pinch gesture). */
+    zoomIn(): void;
+    /** Zoom out one step. */
+    zoomOut(): void;
+    /** Reset the camera so the whole chart fits the container. */
+    zoomToFit(): void;
     /**
-     * An opaque hold id supplied by the host to restore after navigation. It is
-     * verified against the event and active server state before anything renders
-     * as owned by this buyer.
+     * Re-acquire the buyer access session after your app re-authorizes the buyer
+     * (Sales Channels). Resolves false when the chart is not access-scoped.
      */
-    initialHoldId?: string;
+    refreshAccess(): Promise<boolean>;
+}
+/**
+ * Every method a wrapper must forward. The wrappers build their handle by
+ * iterating this, so the list IS the contract rather than a description of it.
+ */
+declare const SEATING_CHART_HANDLE_METHODS: readonly ["hold", "resumeHold", "getCurrentHold", "getGAAreas", "holdGA", "bestAvailable", "release", "releaseLabels", "getSelection", "selectObjects", "deselectObjects", "clearSelection", "selectCategories", "deselectCategories", "setSelectableObjects", "setMaxSelection", "getSelectionValidity", "setSeatTier", "getFloors", "setFloor", "setColorblindSafe", "zoomIn", "zoomOut", "zoomToFit", "refreshAccess"];
+type SeatingChartHandleMethod = (typeof SEATING_CHART_HANDLE_METHODS)[number];
+/**
+ * Build the forwarding object every wrapper exposes.
+ *
+ * `getInstance` is a function rather than the instance itself: a wrapper's
+ * handle is created ONCE and must keep working across rebuilds, so it has to
+ * read the current chart on each call instead of capturing one.
+ */
+declare function bindSeatingChartHandle(getInstance: () => SeatingChart | null): SeatingChartHandle;
+/**
+ * Props whose change means a DIFFERENT chart, so the wrapper tears the canvas
+ * down and builds a new one. Everything else is read live: a parent re-render
+ * must never destroy a canvas mid-selection.
+ *
+ * `initialView` and `errorDisplay` are here because they are read once at
+ * construction and never re-applied — leaving them out does not make them
+ * "live", it makes them silently ignored after mount, which is the worse of the
+ * two behaviours. React already treated them this way; Vue and Angular did not
+ * expose them at all.
+ */
+declare const SEATING_CHART_IDENTITY_PROPS: readonly ["event", "apiBase", "maxSelection", "numberOfPlacesToSelect", "selectionValidators", "publicKey", "locale", "currency", "colorblindSafe", "initialView", "errorDisplay"];
+type SeatingChartIdentityProp = (typeof SEATING_CHART_IDENTITY_PROPS)[number];
+/** Non-callback options a wrapper accepts as props/inputs and passes straight through. */
+declare const SEATING_CHART_VALUE_PROPS: readonly ["event", "apiBase", "maxSelection", "numberOfPlacesToSelect", "selectionValidators", "publicKey", "locale", "currency", "colorblindSafe", "initialView", "errorDisplay", "selectedObjects", "selectableObjects", "messages", "seatTooltip", "buyerAccessTokenProvider", "buyerAccessToken"];
+type SeatingChartValueProp = (typeof SEATING_CHART_VALUE_PROPS)[number];
+/** Every callback option a wrapper wires to its own event mechanism. */
+declare const SEATING_CHART_CALLBACK_PROPS: readonly ["onSelectionChange", "onSelectionValidityChange", "onSelectionValid", "onSelectionInvalid", "onSelectionLimit", "onHold", "onHoldRestored", "onHoldExpired", "onGAClick", "onGAPrompt", "onError", "onDeckTap", "onHint", "onSeatHover", "onAccessExpired", "onAccessUnavailable", "onSelectedObjectUnavailable"];
+type SeatingChartCallbackProp = (typeof SEATING_CHART_CALLBACK_PROPS)[number];
+/** The value half of the options, as a wrapper holds it. */
+type SeatingChartValues = Pick<SeatingChartOptions, SeatingChartValueProp>;
+/** The callback half, already bound to the wrapper's event mechanism. */
+type SeatingChartCallbacks = Pick<SeatingChartOptions, SeatingChartCallbackProp>;
+/**
+ * Assemble the options literal for `new SeatingChart(...)`.
+ *
+ * Picks by the lists above rather than spreading, so a wrapper cannot pass a
+ * stray prop of its own (React's `className`/`style`, Vue's attrs) into the
+ * SDK, and cannot forget one either.
+ */
+declare function buildSeatingChartOptions(container: HTMLElement, values: Partial<SeatingChartValues>, callbacks: SeatingChartCallbacks): SeatingChartOptions;
+
+/**
+ * A secure, framework-neutral host for the SeatLayer chart Designer.
+ *
+ * The Designer remains an iframe so a platform never gives its SeatLayer secret
+ * key to a browser. This class owns the iframe lifecycle and accepts messages
+ * only from that iframe's exact origin.
+ */
+type EmbeddedDesignerEventType = 'seatlayer.designer.ready' | 'seatlayer.designer.saved' | 'seatlayer.designer.published' | 'seatlayer.designer.close' | 'seatlayer.designer.error';
+interface EmbeddedDesignerMessage {
+    type: EmbeddedDesignerEventType;
+    chartId?: string;
+    workspaceId?: string;
+    expiresAt?: number;
+    code?: string;
+    message?: string;
+    meta?: unknown;
     /**
-     * Automatically remember the active hold id in sessionStorage and restore it
-     * when this event's picker mounts again. Default true. Set false when the host
-     * owns hold persistence and supplies initialHoldId itself.
+     * Set by the Designer on an error it raised while the editor was already
+     * running (a failed autosave, thumbnail upload, reload…). Such an error is
+     * about ONE operation, not about the session, so the SDK reports it to the
+     * host and leaves the live editor mounted instead of replacing it with the
+     * dead-end card. Absent on older Designer builds — see
+     * {@link EmbeddedDesigner} for the phase-based fallback.
      */
-    restoreHold?: boolean;
+    fatal?: boolean;
+    /** The operation that failed, when `fatal` is `false` (e.g. `'save'`). */
+    action?: string;
+}
+interface EmbeddedDesignerOptions {
+    /** The short-lived URL returned by your backend's Designer-session call. */
+    designerUrl: string;
+    /** CSS selector or element where the iframe is mounted. */
+    container: string | HTMLElement;
     /**
-     * Render the real chart and live seat statuses without allowing selection,
-     * holds or checkout. This is for venue previews and pre-sale Website pages;
-     * it is enforced by the widget even if the event later opens while mounted.
-     * Default false.
+     * Verify the message belongs to the chart your backend opened. When set, the
+     * id is required on `ready` and every runtime lifecycle message. Only an error
+     * raised before the iframe resolves its session may omit it.
      */
-    readOnly?: boolean;
+    expectedChartId?: string;
     /**
-     * Confirm mode: tapping a seat shows a confirmation card with section, row,
-     * seat, category, price and Select/Cancel before it enters the tray. Default
-     * true for the full buyer picker; set false only when the host supplies its
-     * own equivalent confirmation UI.
+     * Verify the message belongs to the workspace your backend opened. Uses the
+     * same ready/runtime requirement and pre-session error exception as
+     * `expectedChartId`.
      */
-    confirmSelection?: boolean;
+    expectedWorkspaceId?: string;
+    title?: string;
+    className?: string;
+    style?: Partial<CSSStyleDeclaration>;
+    allow?: string;
+    referrerPolicy?: ReferrerPolicy;
     /**
-     * Offer a "View from seat" 360° preview (confirm popover + tray chips). The
-     * panorama is generated from the chart geometry, or the organizer's uploaded
-     * photo when a seat carries one. Default true; set false to hide the affordance.
+     * Show the built-in branded loading skeleton and error/expiry card inside the
+     * container while the Designer boots. Defaults to `true`. Set `false` when the
+     * host renders its own loading and error chrome.
      */
-    seatView?: boolean;
+    showLoadingState?: boolean;
     /**
-     * WHERE the buyer goes once their seats are held. Default `'handoff'`.
-     *
-     *   'handoff'  (default, and every integration that has ever existed) the
-     *              widget fires {@link onCheckout} with a holdId and priced line
-     *              items, and YOUR server takes the money. Nothing about this path
-     *              changes, and no payment code is even downloaded.
-     *   'hosted'   the widget takes the money through the gateway the ORGANIZER
-     *              connected, on their account — the "sell tickets with no
-     *              backend" path. Requires the org to be on hosted checkout and
-     *              the event to have a gateway assigned; when it does not, this
-     *              falls back to `'handoff'` for that buyer rather than dead-ending
-     *              them, and reports why through {@link onCheckoutUnavailable}.
-     *
-     * Named for the destination rather than as a boolean flag because there is a
-     * real third answer coming and `hostedCheckout: true` would have no room for
-     * it; spelling the default out also makes a host's intent legible in their own
-     * source instead of hiding it in an absent option.
+     * If the Designer never posts `ready` within this many milliseconds, the host
+     * transitions to the error card with a timeout message. Defaults to `20000`.
+     * Only used when `showLoadingState` is enabled.
+     */
+    loadingTimeoutMs?: number;
+    /**
+     * How to size the iframe's height. The Designer is a full application (its
+     * shell is `position:fixed; height:100dvh`), not flowing content, so it should
+     * fill its box rather than be measured.
      *
-     * TWO THINGS ARE WORTH KNOWING BEFORE YOU SWITCH THIS ON:
+     * - `'fill'` (default): container-aware. On mount the SDK probes whether the
+     *   host gave the container a DEFINITE (bounded) height:
+     *     - **Bounded container** (a fixed-height block, `height`/`max-height`,
+     *       `flex:1; min-h:0`, a resolved `%`, etc.) → the iframe fills 100% of
+     *       that block and tracks its size live via a `ResizeObserver`.
+     *     - **Content-sized container** (the block collapses to whatever the iframe
+     *       measures — typical full-page usage) → the iframe grows so its bottom
+     *       edge reaches the bottom of the viewport (`window.innerHeight -
+     *       iframe.top`), recomputed (rAF-throttled) on `resize` /
+     *       `orientationchange` / `scroll`.
+     *   Either way the result is clamped to `minHeight`. The verdict is cached but
+     *   re-probed on `resize`/`orientationchange` so a responsive host layout can
+     *   flip between the two. The legacy `seatlayer.designer.resize` message is
+     *   ignored in `'fill'` mode: it is circular, because the fixed-position shell
+     *   just echoes the iframe height.
+     * - a number: a fixed pixel height. In this mode the legacy resize message is
+     *   still honoured (unless `autoResize` is `false`) so older hosts keep growing.
      *
-     * 1. It needs the widget's own transport. A host-supplied `transport` owns its
-     *    credentials and its backend, so hosted checkout stays off there (with one
-     *    console warning) rather than reaching past it to api.seatlayer.io.
-     * 2. WHERE A HOSTED GATEWAY RETURNS THE BUYER is settled by {@link returnUrl}
-     *    and by the organizer. Without one — or from an origin the organizer has
-     *    not declared — the buyer comes back to SeatLayer's own buyer page and is
-     *    confirmed THERE, not in this widget. Declare the embedding site under
-     *    Embed domains in the dashboard and pass `returnUrl`, and the buyer
-     *    returns to your page instead. In-page gateways never navigate away at
-     *    all, so they are unaffected either way.
+     * All SDK-managed heights are written with `!important` priority so a host
+     * theme's `iframe { height: … !important }` cannot override them.
      */
-    checkout?: 'handoff' | 'hosted';
+    height?: 'fill' | number;
+    /** Minimum height (px) that `'fill'` mode clamps to. Defaults to `480`. */
+    minHeight?: number;
     /**
-     * Where a redirecting gateway should send the buyer back to, for
-     * `checkout: 'hosted'`.
-     *
-     * The server keeps this URL's path and query and adds only a non-secret
-     * `seatlayer_checkout=success|cancelled` outcome. The SDK keeps the order id
-     * in this tab's sessionStorage before leaving for the gateway. Point this at
-     * a page on the same origin (often `window.location.href`) and mount a picker
-     * there so it can resume without putting the order capability in a URL.
+     * Auto-grow the iframe to the height the Designer reports over the resize
+     * protocol (`seatlayer.designer.resize`). Only applies when `height` is a fixed
+     * number; ignored in `'fill'` mode. Defaults to `true`. Set `false` when the
+     * host sizes a fixed-height iframe itself.
+     */
+    autoResize?: boolean;
+    /**
+     * Called when the user presses "Try again" on the error card. Use it to mint a
+     * fresh Designer session and call `setDesignerUrl()` with the new URL, which
+     * recreates the iframe and returns to the loading state. When omitted, "Try
+     * again" reloads the current `designerUrl` in place.
      *
-     * It is validated, not trusted: the organizer declares their embed origins
-     * in the dashboard, and an undeclared origin is ignored rather than
-     * refused — the sale still completes, the buyer just finishes on
-     * SeatLayer's page. Supplying a URL therefore cannot authorize it, which is
-     * what stops a copied snippet from redirecting a paid buyer anywhere it
-     * likes.
-     * As with every script embed, code already running on the host origin can
-     * read that origin's sessionStorage; iframe embedding provides SOP isolation.
+     * When supplied, it also powers automatic session renewal — see
+     * {@link EmbeddedDesignerOptions.autoRenewSession}.
      */
-    returnUrl?: string;
+    onRequestRelaunch?: () => void;
     /**
-     * Buyer pressed the CTA and the hold succeeded — hand off to YOUR checkout.
-     * `hold` and `seats` are the legacy args (unchanged since 0.6). `handoff` (P4)
-     * is the stable, self-contained {@link CheckoutHandoff} to build your order
-     * against — holdId, expiry, currency and priced line items. Prefer it.
+     * Keep long editing sessions alive without the user ever hitting the expiry
+     * wall. Designer sessions are short-lived security tokens; when the host wires
+     * `onRequestRelaunch` the SDK, with this enabled, will:
      *
-     * Under `checkout: 'hosted'` this fires ONLY when hosted checkout cannot run
-     * for this event, so a host can keep one code path for both. It never fires
-     * alongside a payment the widget is taking itself.
+     * - **Renew proactively.** From each `ready` message's `expiresAt` it schedules
+     *   a silent relaunch shortly before the session lapses (~3 min ahead; for a
+     *   TTL under 15 min it renews after 80% of the remaining life, and never
+     *   sooner than 30s after `ready`). The host mints a fresh session and swaps
+     *   `designerUrl`, so the editor keeps working with no error card.
+     * - **Recover on expiry.** If an expiry error still slips through (a slept
+     *   laptop woke past the renewal window, say) it makes ONE automatic relaunch
+     *   attempt before showing the "Try again" card, and only falls back to the
+     *   card if that relaunch also fails.
+     *
+     * Defaults to `true` whenever `onRequestRelaunch` is provided; a no-op without
+     * it. Set `false` to keep the fully manual "Try again" behavior.
      */
-    onCheckout?: (hold: HoldResult, seats: PickerSeat[], handoff: CheckoutHandoff) => void;
+    autoRenewSession?: boolean;
+    onReady?: (message: EmbeddedDesignerMessage) => void;
+    onSaved?: (message: EmbeddedDesignerMessage) => void;
+    onPublished?: (message: EmbeddedDesignerMessage) => void;
+    onClose?: (message: EmbeddedDesignerMessage) => void;
+    onError?: (message: EmbeddedDesignerMessage) => void;
+}
+/** Mount, replace, and destroy a scoped Designer iframe safely. */
+declare class EmbeddedDesigner {
+    private options;
+    private frame;
+    private designerOrigin;
+    private overlay;
+    private timeoutTimer;
+    /** Proactive session-renewal timer; armed from each `ready`, cleared on re-mount. */
+    private renewTimer;
+    /** Last identity-checked session expiry, so a live policy change can re-arm. */
+    private sessionExpiresAt;
     /**
-     * `checkout: 'hosted'` was asked for and this event cannot take money.
-     * The seats ARE held — the buyer is mid-journey — so this is a routing
-     * decision, not an error, and it is never collapsed into {@link onError}.
-     *
-     * `reason` carries the server's three-way answer verbatim, because two of the
-     * three give opposite advice: `payments_off_for_event` means the organizer
-     * deliberately does not sell this event online (nothing is wrong), while
-     * `unavailable_for_event` means they switched it on and it is broken. Anything
-     * unreadable — a failed lookup, an older worker — reads as `not_configured`,
-     * which asserts the least about them.
-     *
-     * `onCheckout` fires immediately after this with the same hold. Supply either
-     * (or both) and you own the next screen; supply NEITHER and the widget shows
-     * the buyer an honest card of its own rather than swallowing the press.
+     * One automatic recovery relaunch is allowed per expiry. Reset ONLY when a fresh
+     * `ready` arrives — deliberately not on re-mount — so a session that keeps failing
+     * to load can't loop the host through endless silent relaunches.
      */
-    onCheckoutUnavailable?: (event: {
-        reason: PaymentOptionsReason;
-        handoff: CheckoutHandoff;
-    }) => void;
+    private autoRecoverUsed;
+    private phase;
     /**
-     * `checkout: 'hosted'` only — the gateway's webhook landed and the order is
-     * PAID. The one signal a host with no backend actually needs, and the only
-     * place a receipt can come from on a page that has no server of its own.
-     *
-     * Distinct from {@link onBooked}, which reports the same sale seen from the
-     * seat map over the realtime channel and cannot fire at all for a buyer whose
-     * widget was torn down by a redirect to the gateway.
+     * Set only after an identity-checked `ready`. Unlike `phase`, this remains true
+     * if a later fatal error renders the error card, so no subsequent callback can
+     * shed the chart/workspace identity the live session already established.
      */
-    onOrderConfirmed?: (order: OrderStatusResult) => void;
+    private identityEstablished;
+    private restoreContainerPosition;
+    private pinned;
+    private frameStyleBeforeFs;
+    private docOverflowBeforeFs;
+    private bodyOverflowBeforeFs;
+    private fsKeyHandler;
+    /** Latest height (px string) the Designer reported; re-applied after unpin. */
+    private lastAutoHeight;
+    private fillRaf;
+    private reprobeRaf;
+    private fillListening;
+    /** Resolved container element (fill measurement + ResizeObserver target). */
+    private containerEl;
+    /** Cached fill verdict: 'container' = bounded block, 'viewport' = full page. */
+    private fillMode;
+    /** Live block-size tracking in container-fill mode; disconnected on destroy. */
+    private resizeObs;
+    constructor(options: EmbeddedDesignerOptions);
+    mount(): HTMLIFrameElement;
+    /** Replace the iframe instead of assigning a new fragment to an existing one. */
+    setDesignerUrl(designerUrl: string): HTMLIFrameElement;
+    getIframe(): HTMLIFrameElement | null;
+    /** Update iframe sizing without replacing the live Designer session. */
+    setSizing(height: 'fill' | number | undefined, minHeight: number | undefined): void;
+    /** Update renewal/expiry-recovery policy without replacing the iframe. */
+    setRelaunchPolicy(onRequestRelaunch: (() => void) | undefined, autoRenewSession: boolean | undefined): void;
+    destroy(): void;
+    private loadingStateEnabled;
+    private autoResizeEnabled;
+    /** Fill mode is the default; a numeric `height` opts into a fixed pixel box. */
+    private fillEnabled;
+    /** Write an SDK-managed height with `!important` so a host theme can't win. */
+    private setFrameHeight;
     /**
-     * The held seats were BOOKED (P4) — your server completed payment and the
-     * booking landed over the realtime channel while the widget was still open.
-     * The widget shows a success state; use this to advance your own UI (receipt,
-     * redirect). Fires once per hold.
+     * Decide whether the host gave the container a DEFINITE (bounded) height — a
+     * fixed block the embed should fill 100% of — versus a content-sized container
+     * that collapses to whatever the iframe measures (full-page usage).
+     *
+     * We drive the iframe to two extreme heights within a single synchronous task
+     * and watch whether the container follows: a bounded box barely moves, a
+     * content-sized one grows with the iframe. Because we restore the height before
+     * yielding, the browser only lays out — it never paints the extremes, so there
+     * is no visible flash. Works for px, resolved `%`, and flex (`flex:1;min-h:0`)
+     * heights, and leaves a mere `min-height` floor classified as content-sized so
+     * full-page hosts keep the old viewport-fill behavior.
      */
-    onBooked?: (handoff: CheckoutHandoff) => void;
-    /** Selection changed (tap or best-available). */
-    onSelectionChange?: (seats: PickerSeat[]) => void;
-    /** Selection-rule state after each selection change. */
-    onSelectionValidityChange?: (state: PickerSelectionValidity) => void;
-    /** The configured selection rules have just become valid. */
-    onSelectionValid?: (seats: PickerSeat[]) => void;
-    /** The configured selection rules have just become invalid. */
-    onSelectionInvalid?: (state: PickerSelectionValidity) => void;
-    /** A selection attempt reached the active maximum. */
-    onSelectionLimit?: (maxSelection: number) => void;
+    private detectFillMode;
     /**
-     * Active hold changed because it was created, restored, extended, partially
-     * released, or fully released. Hosts should persist this state for route
-     * navigation and clear their checkout cart when `hold` becomes null.
+     * Size the iframe for the current fill verdict, clamped to `minHeight`. In
+     * container mode it fills 100% of the bounded block; in viewport mode its
+     * bottom edge meets the bottom of the viewport (`window.innerHeight - top`).
+     * No-op while pinned fullscreen (the pin fills the viewport itself).
      */
-    onHoldChange?: (hold: HoldResult | null, seats: PickerSeat[], handoff: CheckoutHandoff | null) => void;
-    /** The open hold expired server-side (widget already reset itself). */
-    onHoldExpired?: () => void;
-    /** A prior active hold was verified and restored into the tray. */
-    onHoldRestored?: (hold: HoldResult, seats: PickerSeat[], handoff: CheckoutHandoff) => void;
-    /** Modal only: the buyer closed the picker (ESC / scrim / ✕). */
-    onClose?: () => void;
+    private applyFill;
+    /** rAF-throttled fill recompute, so a burst of scroll/RO ticks coalesces. */
+    private scheduleFill;
     /**
-     * The buyer access session lapsed. `refreshed` says whether the provider
-     * already recovered it — false means private inventory is now unavailable and
-     * `onAccessUnavailable` follows. Never collapsed into `onError`: an expiry is
-     * a recoverable, buyer-explainable state, not a network failure (guide §10).
+     * rAF-throttled re-probe: a host layout change (responsive breakpoint, a block
+     * gaining/losing a definite height) can flip the verdict, so `resize` /
+     * `orientationchange` re-detect and swap the container observer accordingly.
      */
-    onAccessExpired?: (event: BuyerAccessExpiredEvent) => void;
+    private scheduleReprobe;
+    /** Attach/detach the container ResizeObserver to match the current verdict. */
+    private syncContainerObserver;
+    private startFill;
+    private stopFill;
     /**
-     * Private inventory is unavailable and refreshing will not fix it — revoked,
-     * paused, wrong origin/event/mode, or the provider failed. Carries a reason,
-     * never a channel name, id, colour or count. The widget shows its own
-     * explanatory panel; return nothing to keep it, or handle the state yourself.
+     * Pin the iframe over the host page as a viewport-filling overlay. We save the
+     * iframe's inline style and the document scroll state so `unpinFullscreen`
+     * restores everything exactly. Escape (host-side) also exits.
      */
-    onAccessUnavailable?: (event: BuyerAccessUnavailableEvent) => void;
+    private pinFullscreen;
+    /** Undo `pinFullscreen`: restore the iframe style + scroll lock. Idempotent. */
+    private unpinFullscreen;
+    private clearTimeoutTimer;
     /**
-     * Selected-but-unheld units stopped being selectable — someone else took
-     * them, or an allocation change moved them out of this buyer's scope. The
-     * widget has already dropped them from the tray.
+     * Auto-renewal (proactive + one expiry recovery) is on when the host wired a
+     * relaunch hook and did not opt out. Without the hook there is nothing to call,
+     * so it is a no-op.
      */
-    onSelectedObjectUnavailable?: (event: SelectedObjectUnavailableEvent) => void;
+    private autoRenewEnabled;
+    private clearRenewTimer;
     /**
-     * A buyer tapped a general-admission area (on the map, or in the tray's
-     * `Areas` list) and the widget is about to open its own quantity prompt.
+     * Arm the proactive renewal timer from a `ready` message's `expiresAt` (epoch
+     * ms). We relaunch a comfortable lead before expiry so the host can mint a fresh
+     * session and swap `designerUrl` without the user ever seeing the expiry card:
      *
-     * Return `true` to take the interaction over completely — the built-in
-     * popover/sheet is suppressed, and the host drives the choice with whatever
-     * UI it likes, landing the result through `prompt.confirm(quantity)` (a plain
-     * number for a single-tier area, or `{ [tierId]: quantity }`) or dropping it
-     * with `prompt.cancel()`. Return anything else (or nothing) and the built-in
-     * prompt opens as usual, so this is also usable as a plain notification.
+     * - normal TTL (≥ 15 min): renew {@link RENEW_LEAD_MS} (~3 min) before expiry;
+     * - short TTL (< 15 min): renew after {@link RENEW_SHORT_TTL_FRACTION} (80%) of
+     *   the remaining life, so the lead can't overshoot the whole session;
+     * - either way, never sooner than {@link RENEW_MIN_DELAY_MS} (30s) after `ready`
+     *   so a burst of `ready` messages can't spin the host.
      *
-     * `prompt.max` already folds in the area's live availability AND the
-     * order-wide ticket cap minus everything chosen elsewhere; a `confirm` above
-     * it is clamped rather than rejected.
+     * Re-armed on every `ready`; cleared on destroy / setDesignerUrl (via re-mount).
+     * A no-op when auto-renewal is off or `expiresAt` is missing/already past — the
+     * expiry-error path recovers a session that has already lapsed.
      */
-    onGAPrompt?: (prompt: GAPromptRequest) => boolean | void;
-    onError?: (err: unknown) => void;
+    private scheduleRenewal;
+    private ensureContainerPositioned;
+    private restoreContainerStyle;
+    private removeOverlay;
+    private showError;
+    private handleTryAgain;
+    /**
+     * Build (or rebuild) the overlay for the given phase. A single overlay element
+     * is reused so we never stack stale skeletons or cards.
+     */
+    private renderOverlay;
+    private buildSkeleton;
+    private buildErrorCard;
+    private handleMessage;
 }
 
 /** What the saved-seat comparison chip needs from the widget around it. */
@@ -2261,6 +2371,143 @@ declare class View3dCompareChip {
     mainButton(): HTMLElement | null;
 }
 
+/**
+ * The cart's arithmetic, in ONE place.
+ *
+ * Held server lines, freshly-picked seats and pending GA quantities, all priced
+ * through the picker's own `paidPrice`. The tray renders from this and the
+ * WebMCP `get_selection` tool reads it, so a buyer looking at the sheet and an
+ * agent asking what is selected can never be told two different totals — which
+ * is exactly what a second copy of these six reduces would eventually produce.
+ *
+ * It lives here rather than on SeatPicker because that file is pinned at its
+ * size in the app's file-size ratchet and may not grow, and because a pure
+ * function over a named slice is easier to check than a method with fifty
+ * neighbours.
+ */
+
+/** A chart category as far as pricing is concerned. */
+interface PricedCategory {
+    key?: string;
+    price?: number;
+    tiers?: {
+        id?: string;
+        price: number;
+    }[];
+}
+
+/**
+ * WebMCP tools for the buyer picker (`webMcp` option, off by default).
+ *
+ * An AI agent running in the buyer's browser drives the REAL widget through the
+ * same functions a tap does — search, select, and (only when the integrator
+ * opts in) hold — instead of guessing at pixels. Nothing here runs unless the
+ * host asked for it, and nothing here may break a render: a runtime without the
+ * API, or one that rejects a registration, costs one console.warn. The module
+ * talks to a narrow `WebMcpHost` rather than to `SeatPicker`, so every tool is
+ * testable without mounting a widget.
+ */
+/** Event facts the picker learned when the chart loaded. */
+interface WebMcpEventFacts {
+    name: string;
+    venue: string | null;
+    startsAt: number | null;
+    timezone: string | null;
+    currency: string;
+    salesClosed: boolean;
+}
+interface WebMcpCategoryFacts {
+    key: string;
+    label: string;
+    price?: number;
+    priceRange?: {
+        min: number;
+        max: number;
+    };
+    available: number;
+}
+/** One bookable seat, flattened for search. Ids/labels stay the picker's. */
+interface WebMcpSeatFacts {
+    id: string;
+    label: string;
+    /** Contiguity owner: the logical row a run may not bridge. */
+    rowKey: string;
+    /** Section owner, used by the `together: false` relaxation. */
+    sectionKey: string;
+    /** Seat order inside the row; a missing integer marks an aisle. */
+    index: number;
+    categoryKey: string;
+    /** The price the buyer would actually pay (channel/host overrides applied). */
+    price: number;
+    zoneId?: string;
+    available: boolean;
+}
+/** Buyer-facing words for one seat — the SAME short row/seat the widget's own
+ *  seat card prints, never the raw row label ("Stalls A A"), which repeats the
+ *  section and reads to an agent as a bug. */
+interface WebMcpSeatWords {
+    section: string;
+    row: string;
+    seat: string;
+    category: string;
+}
+interface WebMcpSelectionState {
+    seats: Array<WebMcpSeatWords & {
+        id: string;
+        label: string;
+        price: number;
+    }>;
+    count: number;
+    total: number;
+    currency: string;
+    hold: {
+        id: string;
+        expiresAt: number;
+    } | null;
+    validity: unknown;
+}
+type WebMcpHoldOutcome = {
+    ok: true;
+    hold: {
+        id: string;
+        expiresAt: number;
+    };
+    handoff?: unknown;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Everything the tools need from the widget, and nothing else. */
+interface WebMcpHost {
+    event(): WebMcpEventFacts | null;
+    selectionLimits(): {
+        max: number;
+        required: number | null;
+    };
+    categories(): WebMcpCategoryFacts[];
+    zones(): Array<{
+        id: string;
+        label: string;
+    }>;
+    hasPremiumSeats(): boolean;
+    seats(): WebMcpSeatFacts[];
+    /** Buyer-facing spatial words for one seat, resolved lazily per result. */
+    describeSeat(id: string): WebMcpSeatWords | null;
+    selection(): WebMcpSelectionState;
+    clearSelection(): void;
+    selectObjects(ids: string[]): void;
+    hold(): Promise<WebMcpHoldOutcome>;
+}
+interface WebMcpRegistration {
+    /** Tool names actually registered, in registration order. */
+    names: string[];
+    /** Abort the registration signal; unregister by name where supported. */
+    dispose: () => void;
+}
+
+/** What `PickerController.render()` reports back about the loaded event. */
+type PickerRenderInfo = NonNullable<Awaited<ReturnType<PickerController['render']>>>;
+
 declare class SeatPicker implements GaPromptPicker {
     /** @internal Read by pickerGaPrompt for the `onGAPrompt` host hook. */
     readonly opts: SeatPickerOptions;
@@ -2277,7 +2524,7 @@ declare class SeatPicker implements GaPromptPicker {
     /** @internal */ readonly controller: PickerController;
     /** @internal */ maxTickets: number;
     /** Exact ticket count required before checkout; null keeps ordinary 1..max behavior. */
-    private readonly exactTickets;
+    /** @internal */ readonly exactTickets: number | null;
     private lastSelectionValidity;
     /** Original host pricing, kept separate from live server offer overrides. */
     private readonly hostPricing;
@@ -2287,7 +2534,11 @@ declare class SeatPicker implements GaPromptPicker {
     /** @internal */ root: HTMLDivElement | null;
     private mapHost;
     private rendered;
-    private destroyed;
+    /** @internal */ destroyed: boolean;
+    /** @internal Chart-load facts; WebMCP's describe_event answers from them. */
+    renderInfo: PickerRenderInfo | null;
+    /** @internal Live WebMCP registration, when the host opted in. */
+    webMcp: WebMcpRegistration | null;
     /** Bumped on every locale REQUEST, so a load that resolves late can tell it
      *  is no longer the one asked for. See {@link applyActiveLocale}. */
     private localeGeneration;
@@ -2304,15 +2555,15 @@ declare class SeatPicker implements GaPromptPicker {
     private offerVisibilityHandler;
     /** Short-lived UI motion timers; all are cancelled on destroy. */
     private motionTimers;
-    private currency;
+    /** @internal */ currency: string;
     private eventTimezone;
     /** The event's formatted date-time (event-zone), reused by the closed-state note. */
     private eventWhenText;
     private offerAvailability;
     /** Server-authoritative channel rules, projected only for this buyer scope. */
     private readonly channelByObject;
-    private readonly pricesByChannel;
-    private hold;
+    /** @internal */ readonly pricesByChannel: Map<string, ChannelPriceOverride[]>;
+    /** @internal */ hold: HoldResult | null;
     /** Latest server expiry for the open hold (moves on extend). */
     private holdExpiresAt;
     /** True once we handed off to checkout — arms booked-confirmation detection. */
@@ -2539,6 +2790,9 @@ declare class SeatPicker implements GaPromptPicker {
     /** Controller callbacks are wired once, before the first async chart load. */
     private wireController;
     render(): Promise<this>;
+    /** @internal Both hand off to pickerWebMcpBridge, which owns the mapping. */
+    registerAgentTools(): Promise<void>;
+    /** @internal */ webMcpHost(holds: boolean): WebMcpHost;
     /** Wire host chrome after the skeleton exists and before the renderer owns its map host. */
     private wireBuyerShell;
     /**
@@ -2656,7 +2910,7 @@ declare class SeatPicker implements GaPromptPicker {
     /** A completed hold gets one short map ripple per concrete seat. */
     private flashHeldSeats;
     /** Update only the action affordance; selection callbacks must not refire. */
-    private committedSelection;
+    /** @internal */ committedSelection(): PickerSeat[];
     private pendingSelectionCount;
     private heldTicketCount;
     /** @internal */ totalTicketCount(): number;
@@ -2676,10 +2930,11 @@ declare class SeatPicker implements GaPromptPicker {
     /** Attach the F3 overview minimap into the bottom-left chrome region. */
     private buildMinimap;
     /** Effective category summary price. Object-specific channel prices are added to the range below. */
-    private catPrice;
-    /** Complete buyer-visible price range, including every ticket tier and
-     * tier-specific host override. */
-    private catPriceRange;
+    /** @internal */ catPrice(c: PricedCategory): number | undefined;
+    /** @internal */ catPriceRange(c: PricedCategory): {
+        min: number;
+        max: number;
+    } | undefined;
     /** Build the compact price selector in the panel header. Choosing a band both
      *  filters availability and smoothly frames the matching seats on the map. */
     private buildPriceFilter;
@@ -2818,7 +3073,7 @@ declare class SeatPicker implements GaPromptPicker {
      */
     private removeHeldLabels;
     private handleChangeSeats;
-    private handleCta;
+    /** @internal */ handleCta(): Promise<void>;
     private startHoldTimer;
     private stopHoldTimer;
     /** Show/refresh (or hide) the "Need more time?" prompt with the live seconds left. */
@@ -3747,4 +4002,4 @@ interface AttachPickerFrameOptions {
  */
 declare function attachPickerFrame(iframe: HTMLIFrameElement, opts?: AttachPickerFrameOptions): () => void;
 
-export { ApiError, type AttachPickerFrameOptions, type BestAvailableResult, BuyerAccessContext, type BuyerAccessExpiredEvent, type BuyerAccessRefreshReason, type BuyerAccessToken, type BuyerAccessTokenProvider, BuyerAccessUnavailableError, type BuyerAccessUnavailableEvent, type BuyerAccessUnavailableReason, BuyerRealtimeClient, type BuyerRealtimeOptions, type CheckoutHandoff, type CheckoutLineItem, type CheckoutSessionResult, EmbeddedDesigner, type EmbeddedDesignerEventType, type EmbeddedDesignerMessage, type EmbeddedDesignerOptions, type GAAreaAvailability, type GAPromptRequest, type GaPromptTier, type HoldConflict, type HoldLineItem, type HoldResult, type OrderStatusResult, type PaymentOptionsReason, type PaymentOptionsResult, type PaymentProviderName, type PerformanceGroupAvailability, type PerformanceGroupCheckoutHandoff, type PerformanceGroupDescriptor, PerformanceGroupDestroyedError, type PerformanceGroupHold, type PerformanceGroupHoldAllocation, type PerformanceGroupOperationEvent, type PerformanceGroupOperationState, PerformanceGroupPicker, type PerformanceGroupPickerOptions, type PerformanceGroupRecoveryState, type PerformanceGroupSeatAllocation, type PerformanceGroupSelectionMode, type PerformanceGroupStatusEvent, type Projection, type PubApiOptions, type RealtimeSink, type ResumedHoldResult, SEATING_CHART_CALLBACK_PROPS, SEATING_CHART_HANDLE_METHODS, SEATING_CHART_IDENTITY_PROPS, SEATING_CHART_VALUE_PROPS, type SaleState, SeasonApiError, type SeasonAvailability, type SeasonCheckoutHandoff, type SeasonDescriptor, type SeasonOperation, type SeasonOperationState, SeasonPicker, type SeasonPickerOptions, SeasonRecoveryTimeoutError, type SeasonRenewalIntent, type SeasonStatusEvent, SeatPicker, type SeatPickerBestAvailableOptions, type SeatPickerBuyerView, type SeatPickerBuyerViewOptions, type SeatPickerOptions, type SeatPickerPricing, type SeatPickerTheme, SeatingChart, type SeatingChartCallbackProp, type SeatingChartCallbacks, type SeatingChartHandle, type SeatingChartHandleMethod, type SeatingChartIdentityProp, type SeatingChartOptions, type SeatingChartValueProp, type SeatingChartValues, type SelectedObjectUnavailableEvent, type SelectedSeat, type StatusChange, type SubscribeTicket, ThemeMode, type TicketOfferAvailability, type TicketOfferPrice, type TicketOfferSummary, attachPickerFrame, bindSeatingChartHandle, buildSeatingChartOptions, createBuyerAccessContext, createControllerSink, parseTicketOfferAvailability, shortOperationReference, ticketOfferPrices };
+export { ApiError, type AttachPickerFrameOptions, type BestAvailableResult, BuyerAccessContext, type BuyerAccessExpiredEvent, type BuyerAccessRefreshReason, type BuyerAccessToken, type BuyerAccessTokenProvider, BuyerAccessUnavailableError, type BuyerAccessUnavailableEvent, type BuyerAccessUnavailableReason, BuyerRealtimeClient, type BuyerRealtimeOptions, type CheckoutHandoff, type CheckoutLineItem, type CheckoutSessionResult, EmbeddedDesigner, type EmbeddedDesignerEventType, type EmbeddedDesignerMessage, type EmbeddedDesignerOptions, type GAAreaAvailability, type GAPromptRequest, type GaPromptTier, type HoldConflict, type HoldLineItem, type HoldResult, type OrderStatusResult, type PaymentOptionsReason, type PaymentOptionsResult, type PaymentProviderName, type PerformanceGroupAvailability, type PerformanceGroupCheckoutHandoff, type PerformanceGroupDescriptor, PerformanceGroupDestroyedError, type PerformanceGroupHold, type PerformanceGroupHoldAllocation, type PerformanceGroupOperationEvent, type PerformanceGroupOperationState, PerformanceGroupPicker, type PerformanceGroupPickerOptions, type PerformanceGroupRecoveryState, type PerformanceGroupSeatAllocation, type PerformanceGroupSelectionMode, type PerformanceGroupStatusEvent, type Projection, type PubApiOptions, type RealtimeSink, type ResumedHoldResult, SEATING_CHART_CALLBACK_PROPS, SEATING_CHART_HANDLE_METHODS, SEATING_CHART_IDENTITY_PROPS, SEATING_CHART_VALUE_PROPS, type SaleState, SeasonApiError, type SeasonAvailability, type SeasonCheckoutHandoff, type SeasonDescriptor, type SeasonOperation, type SeasonOperationState, SeasonPicker, type SeasonPickerOptions, SeasonRecoveryTimeoutError, type SeasonRenewalIntent, type SeasonStatusEvent, SeatPicker, type SeatPickerBestAvailableOptions, type SeatPickerBuyerView, type SeatPickerBuyerViewOptions, type SeatPickerOptions, type SeatPickerPricing, type SeatPickerTheme, type SeatPickerWebMcpOptions, SeatingChart, type SeatingChartCallbackProp, type SeatingChartCallbacks, type SeatingChartHandle, type SeatingChartHandleMethod, type SeatingChartIdentityProp, type SeatingChartOptions, type SeatingChartValueProp, type SeatingChartValues, type SelectedObjectUnavailableEvent, type SelectedSeat, type StatusChange, type SubscribeTicket, ThemeMode, type TicketOfferAvailability, type TicketOfferPrice, type TicketOfferSummary, attachPickerFrame, bindSeatingChartHandle, buildSeatingChartOptions, createBuyerAccessContext, createControllerSink, parseTicketOfferAvailability, shortOperationReference, ticketOfferPrices };