@seatlayer/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,826 @@
+/**
+ * SeatMap chart document — the single source of truth shared by the
+ * Designer (authoring) and the Renderer (buyer picker).
+ *
+ * Mirrors docs/seatmap-build-spec.md §5. Coordinates are abstract units
+ * (roughly "pixels at scale 1"); the renderer fits the chart to its container.
+ * Rows are PARAMETRIC (origin + count + spacing + curve + rotation) — never
+ * store per-seat coordinates in the document; expansion happens in layout.ts.
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+interface Category {
+    key: string;
+    label: string;
+    color: string;
+    /** Demo-only convenience; real pricing comes from ticket tiers server-side. */
+    price?: number;
+}
+/**
+ * Accessibility accommodations a seat can carry. Mirrors the taxonomy real
+ * venues (and seats.io) expose so buyers can filter for exactly what they need
+ * and organizers can mark seats precisely. `wheelchair` is the legacy default.
+ */
+type AccessibilityType = 'wheelchair' | 'companion' | 'semi-ambulatory' | 'hearing' | 'sign-language' | 'plus-size' | 'lift-armrest';
+interface AccessibilityMeta {
+    key: AccessibilityType;
+    /** Full descriptive label (designer checkbox, picker legend). */
+    label: string;
+    /** Compact label for chips/badges. */
+    short: string;
+    /** Single-glyph badge shown on seat chips + filter chips. */
+    icon: string;
+}
+/** Ordered taxonomy — drives the designer seat panel and the picker filters. */
+declare const ACCESSIBILITY_TYPES: AccessibilityMeta[];
+/** Metadata for one accessibility key (undefined for unknown keys). */
+declare function accessibilityMeta(key: AccessibilityType): AccessibilityMeta | undefined;
+interface SeatOverride {
+    /** 0-based seat index within the row. */
+    index: number;
+    /** Physical seat absent (pillar, sound desk) — numbering gap preserved. */
+    skip?: boolean;
+    /** Position nudge in chart units. */
+    dx?: number;
+    dy?: number;
+    /** Replace the computed label entirely. */
+    label?: string;
+    categoryKey?: string;
+    /** @deprecated legacy flag — read as `['wheelchair']`; write `accessibility`. */
+    accessible?: boolean;
+    /** Accessibility accommodations of this seat (empty/absent = none). */
+    accessibility?: AccessibilityType[];
+}
+/** Brand/venue theming — applied by the renderer in both designer and picker. */
+interface ChartTheme {
+    /** Canvas background color (default dark: #0e1117-ish radial). */
+    background?: string;
+    /** Seat label text color (default dark ink #0b1220). */
+    seatLabelColor?: string;
+    /** Selection ring / accent color (default white ring + brand accent). */
+    selectionColor?: string;
+    /** Décor (stage/shape) default fill. */
+    decorFill?: string;
+    /** Free-text color default. */
+    textColor?: string;
+    /** Font family (CSS stack) for all rendered text — seat labels, sections, décor text. */
+    fontFamily?: string;
+    /** Seat size multiplier on the base radius (0.7–1.6, default 1) — bigger seats fit longer labels. */
+    seatScale?: number;
+    /** Brand accent color — recolors buttons, links, the hold pill, selection UI. */
+    accent?: string;
+    /** Ink color for text on the accent (e.g. button labels). Default light. */
+    accentInk?: string;
+    /** Organizer logo shown in the picker header (data/R2 URL). Falls back to the name. */
+    logoUrl?: string;
+    /** Brand/venue name shown in the picker header when no event name is set. */
+    brandName?: string;
+    /** Paid-tier flag: hide the "Powered by SeatMap" badge. */
+    hideBadge?: boolean;
+}
+interface RowObject {
+    type: 'row';
+    id: string;
+    /** Row label, e.g. "A". Seat labels are `${label}-${n}`. */
+    label: string;
+    /** Position of the FIRST seat. */
+    origin: Point;
+    /** Degrees, clockwise. 0 = seats laid out along +x. */
+    rotation: number;
+    /**
+     * Total arc sweep in degrees across the whole row. 0 = straight.
+     * Positive bends away from +y (concave toward the focal point when the
+     * row faces it). Typical theatre rows: 10–40.
+     */
+    curve: number;
+    seatCount: number;
+    /** Distance between adjacent seat centers, in chart units. */
+    seatSpacing: number;
+    categoryKey: string;
+    /** First seat number (default 1). */
+    seatLabelStart?: number;
+    /** Seat numbering within the row (default ltr, step 1). */
+    seatNumbering?: {
+        direction: 'ltr' | 'rtl';
+        /** 2 = odd/even numbering (1,3,5… — start at 2 for evens). */
+        step?: 1 | 2;
+    };
+    /**
+     * Per-seat exceptions, keyed by seat index (0-based position in the row).
+     * `skip` removes the physical seat but keeps the numbering gap (theatre
+     * convention: a pillar eats A-3; A-4 stays A-4).
+     */
+    overrides?: SeatOverride[];
+    /**
+     * Organizer-supplied equirectangular 360 (or wide photo) shown as the
+     * view-from-seat for every seat in this row. When absent, the picker
+     * generates a synthetic panorama from chart geometry.
+     */
+    viewFromSeatUrl?: string;
+}
+interface GAAreaObject {
+    type: 'gaArea';
+    id: string;
+    label: string;
+    /** Closed polygon, in chart units. */
+    points: Point[];
+    capacity: number;
+    categoryKey: string;
+}
+/** Non-bookable décor: stage, walls, exits. */
+interface ShapeObject {
+    type: 'shape';
+    id: string;
+    kind: 'rect' | 'ellipse' | 'polygon';
+    label?: string;
+    /** For rect/ellipse: bounding box. For a stage polygon: the base (pre-shape) box, so its kind can be regenerated. */
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    /** For polygon. */
+    points?: Point[];
+    fill?: string;
+    /** Degrees clockwise about the shape's center (default 0). Applied at render time. */
+    rotation?: number;
+    /**
+     * Semantic tag driving special rendering. `'stage'` gets the gradient +
+     * prominent uppercase label treatment; a décor landmark role (bar, exit…)
+     * gets a quieter label. Loose string to avoid a circular import with
+     * stage.ts / decor.ts (see StageKind / DecorRole there).
+     */
+    role?: string;
+    /** For a stage: which `StageKind` its polygon was generated from. */
+    stageKind?: string;
+}
+/** Seats arranged around a table; bookable per-seat or as a whole. */
+interface TableObject {
+    type: 'table';
+    id: string;
+    /** e.g. "T1" — seat labels are `${label}-${n}`. */
+    label: string;
+    center: Point;
+    shape: 'round' | 'rect';
+    /** Seats around the perimeter (round) or along the enabled edges (rect). */
+    seatCount: number;
+    /** Rect tables: which edges get seats (default ['top','bottom']). */
+    sides?: Array<'top' | 'bottom' | 'left' | 'right'>;
+    rotation: number;
+    /** Round tables. */
+    radius?: number;
+    /** Rect tables. */
+    width?: number;
+    height?: number;
+    categoryKey: string;
+    /** Whole-table booking: buyers get all seats or none (per-event override later). */
+    bookAsWhole?: boolean;
+}
+/** A booth: one bookable unit rendered as a block (trade shows, VIP boxes). */
+interface BoothObject {
+    type: 'booth';
+    id: string;
+    label: string;
+    center: Point;
+    width: number;
+    height: number;
+    rotation: number;
+    categoryKey: string;
+}
+/**
+ * A named region of the venue (Balcony Left, Floor B…). Sections are outlines
+ * only — objects belong to a section spatially (center inside the outline),
+ * keeping the document flat (no nesting; simpler for tools and for AI edits).
+ * Renderer: far zoom shows section shapes/labels instead of seats; clicking
+ * a section zooms into it.
+ */
+interface SectionObject {
+    type: 'section';
+    id: string;
+    label: string;
+    /** Closed polygon, chart units. */
+    outline: Point[];
+    /** Optional tint override (defaults to a neutral fill / dominant category mix). */
+    color?: string;
+    /** Zone this section belongs to (id into `ChartDoc.zones`). Far-zoom nav + pricing group. */
+    zone?: string;
+    /**
+     * Tier height. 0 = floor (default). Higher values lift the section in the
+     * picker's isometric ("3D") view, drawn on extruded side faces. Same field a
+     * future multi-floor mode reuses — authored in 2D, never drawn by the user.
+     */
+    elevation?: number;
+    /** Uniform scale about the outline centroid (1 = as drawn). Scales members too. */
+    scale?: number;
+    /** 0–1: how strongly member-row curves are bent toward a common arc fitted to the outline. */
+    smoothing?: number;
+    /** Degrees clockwise about the outline centroid (default 0). Rotates members too. */
+    rotation?: number;
+}
+/**
+ * A group of sections (Lower Bowl, Upper Bowl, Floor…). One concept, three jobs:
+ * the farthest-zoom navigation unit, a pricing group, and (Batch 3) a timed-
+ * release unit. Kept as a flat list on the doc; sections point back by `zone` id.
+ */
+interface ZoneDef {
+    id: string;
+    label: string;
+    color?: string;
+}
+/**
+ * Selection layer — a hit-test/dim filter in the designer, NOT z-order management.
+ * Fixed set of four; derived from object type via `layerOf()` (no per-object field yet).
+ */
+type SelectionLayer = 'interactive' | 'background' | 'foreground' | 'surroundings';
+/** Derive an object's selection layer from its type (design contract, HANDOFF §03). */
+declare function layerOf(obj: ChartObject): SelectionLayer;
+/** Free-standing text on the chart (aisle names, door labels…). */
+interface TextObject {
+    type: 'text';
+    id: string;
+    text: string;
+    position: Point;
+    fontSize: number;
+    rotation: number;
+    color?: string;
+}
+type ChartObject = RowObject | GAAreaObject | ShapeObject | TableObject | BoothObject | TextObject | SectionObject;
+interface ChartDoc {
+    version: 1;
+    name: string;
+    venueType: 'SIMPLE' | 'MIXED';
+    /** The stage / point every seat looks at. Anchors seat-view + sightlines. */
+    focalPoint: Point;
+    categories: Category[];
+    /** Section groupings for far-zoom navigation + pricing (optional; sections reference by id). */
+    zones?: ZoneDef[];
+    objects: ChartObject[];
+    /** Floor-plan photo the organizer traces over (designer-only aid, also rendered dimly in picker if kept). */
+    backgroundImage?: {
+        url: string;
+        center: Point;
+        /** Rendered width in chart units (height follows the image aspect). */
+        width: number;
+        opacity: number;
+        locked?: boolean;
+    };
+    /** Brand/venue theming (colors); categories carry their own colors separately. */
+    theme?: ChartTheme;
+}
+interface ExpandedSeat {
+    /** Stable id: `${rowId}:${index}` */
+    id: string;
+    /** Public label: `${rowLabel}-${seatNumber}` */
+    label: string;
+    x: number;
+    y: number;
+    rowId: string;
+    categoryKey: string;
+    /** 'booth' units render as blocks (dimensions looked up via rowId = booth id). */
+    kind?: 'seat' | 'booth';
+    /** True when the seat has any accessibility accommodation — renderer rings/dims these. */
+    accessible?: boolean;
+    /** Specific accessibility accommodations (absent = none) — picker badges/filters these. */
+    accessibility?: AccessibilityType[];
+    /** Organizer-supplied view-from-seat image (inherited from the row). */
+    viewUrl?: string;
+}
+type SeatStatus = 'free' | 'held' | 'booked' | 'not_for_sale';
+interface RendererCallbacks {
+    onSelect?: (seat: ExpandedSeat) => void;
+    onDeselect?: (seat: ExpandedSeat) => void;
+    /** seat is null when the pointer leaves any seat. */
+    onHover?: (seat: ExpandedSeat | null) => void;
+    /** Keyboard focus moved to a seat (arrow-key navigation) — for screen-reader announcements. */
+    onFocusSeat?: (seat: ExpandedSeat | null) => void;
+    /** Called ~1×/sec with the measured frames-per-second. */
+    onFps?: (fps: number) => void;
+    /** Fired when a GA area is clicked (quantity picking is UI-side). */
+    onGAClick?: (areaId: string) => void;
+    /** Fired after any pan/zoom/resize settles — re-anchor screen-space overlays. */
+    onViewChange?: () => void;
+}
+interface RendererOptions extends RendererCallbacks {
+    /** Max seats selectable at once (default 10). */
+    maxSelection?: number;
+    /** Only these statuses are clickable (default ['free']). */
+    selectableStatuses?: SeatStatus[];
+    /**
+     * Opt-in host behaviour flag — the renderer's own click/selection logic is
+     * unchanged (it still selects + fires `onSelect` immediately, so the seat
+     * highlights right away). When true, the host (e.g. PublicEventPage) treats
+     * that `onSelect` as a pending candidate and shows a confirm card instead of
+     * pushing straight into the cart; `deselect([seat.id])` on Cancel un-highlights.
+     */
+    confirmSelection?: boolean;
+}
+interface ISeatmapRenderer {
+    /** Replace the chart. Resets selection and statuses, zooms to fit. */
+    setChart(doc: ChartDoc): void;
+    /** Bulk status update; re-renders affected seats only. */
+    setStatus(seatIds: string[], status: SeatStatus): void;
+    getStatus(seatId: string): SeatStatus;
+    getSelection(): ExpandedSeat[];
+    clearSelection(): void;
+    /** Programmatic deselect of specific seats (e.g. chip × in the cart). */
+    deselect(seatIds: string[]): void;
+    /**
+     * Brief attention pulse on a seat (a ring that expands + fades once) — used to
+     * signal live activity, e.g. a seat "just taken" by another buyer via a WS
+     * delta. Purely visual; no state change. `color` overrides the default.
+     */
+    flashSeat(seatId: string, color?: string): void;
+    zoomToFit(): void;
+    /** Zoom in one step about the viewport center, clamped to the usual zoom bounds. */
+    zoomIn(): void;
+    /** Zoom out one step about the viewport center, clamped to the usual zoom bounds. */
+    zoomOut(): void;
+    /** Total seat count of the current chart. */
+    seatCount(): number;
+    /**
+     * Maps a chart-space point (or a seat, by its x/y) to container-relative
+     * screen pixels, using the current stage scale/position. Lets host UI anchor
+     * DOM overlays (confirm card, tooltip) over a live seat and re-anchor them
+     * on `onViewChange`.
+     */
+    worldToScreen(point: Point): {
+        x: number;
+        y: number;
+    };
+    /** When on, dim non-accessible free seats so accessible seats stand out. */
+    setAccessibleFilter(on: boolean): void;
+    /**
+     * Dim free seats that lack ANY of these accessibility types. `null` clears the
+     * filter; `[]` means "any accessible seat" (same as setAccessibleFilter(true)).
+     */
+    setAccessibilityFilter(types: AccessibilityType[] | null): void;
+    /** Legend hover-highlight: dim free seats of other categories (null clears). */
+    setCategoryHighlight?(key: string | null): void;
+    /**
+     * Switch the projection. `'flat'` = normal top-down; `'isometric'` = the "3D"
+     * view (affine skew/rotate + elevation lift), hit-testing preserved in screen
+     * space. Purely visual — the chart is authored flat. Animated unless reduced-motion.
+     */
+    setViewMode?(mode: 'flat' | 'isometric'): void;
+    /**
+     * Section id whose outline contains a container-relative screen point (or null).
+     * Feeds the far-zoom "tap a section to zoom in" flow (Slice 5).
+     */
+    sectionAt?(clientPoint: Point): string | null;
+    /** Seat ids belonging to a section — for the section-summary card (Slice 5). */
+    sectionMembers?(id: string): string[];
+    destroy(): void;
+}
+/** localStorage key the Designer writes and the Picker reads. */
+declare const CHART_STORAGE_KEY = "seatmap.chart";
+
+/**
+ * Pure geometry helpers — no Konva, no DOM. Turns the parametric chart
+ * document into concrete seat coordinates and computes bounding boxes.
+ */
+
+/**
+ * Every seat slot of a row INCLUDING skipped ones (designer seat-edit mode uses
+ * this to draw un-skip handles). Overrides (dx/dy/label/categoryKey) are applied
+ * but a skipped slot is flagged, not omitted.
+ */
+interface RowSeatSlot {
+    index: number;
+    x: number;
+    y: number;
+    label: string;
+    categoryKey: string;
+    skipped: boolean;
+    accessible: boolean;
+    accessibility: AccessibilityType[];
+}
+declare function expandRowSlots(row: RowObject): RowSeatSlot[];
+declare function expandRow(row: RowObject): ExpandedSeat[];
+/**
+ * Expand a table into its perimeter seats.
+ *
+ * Round: seats spread evenly on a circle of radius `radius + 16`, the first at
+ * angle `rotation` (degrees, clockwise from +x). Rect: seats line the top and
+ * bottom edges (split evenly, any remainder to the top), 16u outside the edge,
+ * the whole set rotated about the table centre.
+ */
+declare function expandTable(t: TableObject): ExpandedSeat[];
+/** Expand a booth into its single bookable block unit. */
+declare function expandBooth(b: BoothObject): ExpandedSeat[];
+/** Ray-cast point-in-polygon test — odd crossings ⇒ inside. */
+declare function pointInPolygon(p: Point, poly: Point[]): boolean;
+/**
+ * Visual centre of any object — used for spatial section membership and for
+ * rotating an object about its centre. Rows: centroid of expanded seats (or
+ * origin when empty); tables/booths: centre; GA/section: polygon centroid;
+ * shape: bbox centre; text: its position.
+ */
+declare function objectCenter(o: ChartObject): Point;
+/** Expand every seat-bearing object (rows, tables, booths). */
+declare function expandChart(doc: ChartDoc): ExpandedSeat[];
+/** Axis-aligned bounds over every object plus the background image, with padding. */
+declare function chartBounds(doc: ChartDoc): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+
+/**
+ * SeatmapRenderer — the shared canvas rendering core (buyer picker shell).
+ *
+ * Uses Konva directly with per-module imports to keep the bundle lean. The
+ * whole point of the spike is staying smooth at ~5,000 seats on mobile, so the
+ * hot paths lean on: layer bitmap caching + listening(false) when zoomed out,
+ * per-seat fill updates (never full rebuilds) on status change, and viewport-
+ * only label rendering rebuilt on interaction-end rather than per frame.
+ */
+
+declare class SeatmapRenderer implements ISeatmapRenderer {
+    private container;
+    private opts;
+    private stage;
+    private bgLayer;
+    private seatLayer;
+    private overlayLayer;
+    private labelGroup;
+    private seats;
+    private seatById;
+    /** Interactive node per seat/booth — a Circle for seats, a Rect for booths. */
+    private circleById;
+    /** Booth block geometry, keyed by booth id (= the unit's rowId). */
+    private boothDims;
+    private statusById;
+    private catColor;
+    private theme;
+    private selection;
+    private selectionRings;
+    private hoverRing;
+    /** Keyboard-navigation focus ring + the currently focused seat id. */
+    private focusRing;
+    private focusedId;
+    /**
+     * Accessibility filter: `null` = off; `[]` = dim all non-accessible free seats;
+     * a type list = dim free seats lacking any of those accommodations.
+     */
+    private accessFilter;
+    /** Category highlight (legend hover): dims free seats NOT of this category. */
+    private categoryHighlight;
+    private sections;
+    private zones;
+    private seatSection;
+    private catPrice;
+    /** Zone id → colour (drives extruded side faces in iso view). */
+    private zoneColor;
+    private hasSections;
+    /** seatLayer carries Text (booth labels) — gate the upright-label scan. */
+    private hasBoothText;
+    /** 0 = flat (default), 1 = full isometric; animated by setViewMode. */
+    private isoT;
+    private isoTarget;
+    private isoRaf;
+    /** Chart centre the iso projection pivots about (bounds centre). */
+    private isoCentre;
+    /** Set in destroy() so an in-flight iso tween bails. */
+    private destroyed;
+    /** Cached scale the section/zone labels were last sized for (scale-compensation). */
+    private lodScale;
+    /** prefers-reduced-motion → hard-swap rungs instead of cross-fading. */
+    private reducedMotion;
+    private fitScale;
+    /** Effective seat radius (base × theme.seatScale), set per chart in setChart. */
+    private seatR;
+    private bounds;
+    private cached;
+    private dpr;
+    private rafId;
+    private frames;
+    private lastFpsAt;
+    private recacheTimer;
+    private resizeObs;
+    /** Coalesces bursty view-change sources (pointermove, wheel) into ≤1 callback/frame. */
+    private viewChangeRaf;
+    private pointers;
+    private pinch;
+    private panLast;
+    /** Cumulative gesture movement in px — clicks are suppressed after a real pan/pinch. */
+    private moved;
+    constructor(container: HTMLDivElement, options?: RendererOptions);
+    setChart(doc: ChartDoc): void;
+    setStatus(seatIds: string[], status: SeatStatus): void;
+    getStatus(seatId: string): SeatStatus;
+    getSelection(): ExpandedSeat[];
+    clearSelection(): void;
+    deselect(seatIds: string[]): void;
+    flashSeat(seatId: string, color?: string): void;
+    private onKeyDown;
+    /** Nearest seat from `fromId` in a cardinal direction (aligned + close wins). */
+    private nearestSeat;
+    private focusSeat;
+    /** Pan/zoom so a seat sits on-screen at a legible scale (for keyboard focus). */
+    private ensureVisible;
+    zoomToFit(): void;
+    /** Step factor for the on-screen +/− buttons (B1) — same clamp path as pinch/wheel. */
+    private static readonly ZOOM_STEP;
+    zoomIn(): void;
+    zoomOut(): void;
+    seatCount(): number;
+    worldToScreen(point: Point): {
+        x: number;
+        y: number;
+    };
+    setAccessibleFilter(on: boolean): void;
+    setAccessibilityFilter(types: AccessibilityType[] | null): void;
+    private sameAccessFilter;
+    /**
+     * Switch the projection between flat top-down and the isometric "3D" view
+     * (rotate + y-squash about the chart centre, plus per-elevation lift). Tweens
+     * `isoT` 0⇄1 over ~0.32s (ease in-out); reduced-motion snaps. Purely visual —
+     * geometry stays flat, so hit-testing (Konva's own, plus the manual section
+     * inverse) keeps landing on the projected seats/sections.
+     */
+    setViewMode(mode: 'flat' | 'isometric'): void;
+    /** Iso angle (rad) + y-squash for the current isoT. */
+    private isoParams;
+    /** Effective vertical scale = stage scale × iso squash — legibility math uses this. */
+    private effScale;
+    /** Project a world point through the iso affine about the chart centre (→ iso-world). */
+    private isoForward;
+    /** Inverse of isoForward (iso-world → world) for screen-space hit-testing. */
+    private isoInverse;
+    /**
+     * Local-space offset that, once the layer applies the iso affine, lifts an
+     * object straight UP in iso-world by `elevation × LIFT_PER_STEP × isoT`
+     * (= inverse-linear of the pure vertical lift). Zero at isoT=0.
+     */
+    private isoLiftLocal;
+    /** Restore the three layers to identity (flat) — byte-for-byte the original. */
+    private resetLayerTransforms;
+    /**
+     * Apply the current isoT to the scene: the base rotate+squash as a decomposed
+     * layer transform (so seats/décor/rings project together and Konva's own
+     * hit-testing follows), upright counter-transforms on text, and the elevation
+     * lift + extruded side faces on elevated sections.
+     */
+    private applyIso;
+    /** Counter-skew every visible label so it renders upright at its projected anchor. */
+    private applyUprightLabels;
+    /** Lift elevated sections (+ their members) and update their extruded side faces. */
+    private applyElevation;
+    destroy(): void;
+    /** Theme font stack for all rendered text (falls back to Inter). */
+    private labelFont;
+    /**
+     * Where a seat's nodes live: an elevated section's lift group (so the whole
+     * tier shifts with one offset in iso view) or the seat layer directly.
+     */
+    private seatContainer;
+    private renderSeats;
+    /** A booth renders as a click-selectable rounded block (dims from the doc). */
+    private renderBoothUnit;
+    /** Apply fill/stroke/opacity for a seat's current status + selection. */
+    private paintSeat;
+    /** Legend hover: highlight one category (dim the rest), or null to clear. */
+    setCategoryHighlight(key: string | null): void;
+    private renderBackground;
+    /** Organizer floor-plan photo, dimmed, at the very bottom of the bg layer. */
+    private renderBackgroundImage;
+    private renderTable;
+    private renderText;
+    private renderShape;
+    /** Prominent stage caption: uppercase, letter-spaced, larger, softly dimmed. */
+    private addStageLabel;
+    private renderGA;
+    /**
+     * A section renders in three coordinated layers driven by the LOD melt:
+     *   • a faint outline (the existing near-zoom look, untouched),
+     *   • a solid category-mix block that fades in at the block rung, and
+     *   • a name + "N LEFT" sublabel.
+     * Membership (which seats live inside the outline) + the mix fill + the live
+     * availability count are precomputed here (once), not per frame.
+     */
+    private renderSection;
+    /** Recompute a section's availability-tinted fill + "N LEFT" (cheap; on status change). */
+    private refreshSectionFill;
+    /**
+     * Zone rung: one giant screen-constant label per zone (+ optional "FROM $n"),
+     * shown at the farthest zoom in place of per-section detail. Skipped entirely
+     * when the doc declares no zones — sections then stay the far rung (graceful).
+     */
+    private renderZones;
+    /**
+     * THE MELT — a continuous, scale-driven cross-fade across the three rungs:
+     *   seats ⇄ section blocks ⇄ zone blocks.
+     * `blockT` ramps 0→1 as scale falls through [SECTION_PROMINENT, CACHE_THRESHOLD]
+     * so the solid fill is fully present exactly as seats become the cached bitmap
+     * and fade out; `zoneT` ramps 0→1 across [ZONE_PROMINENT, SECTION_PROMINENT] so
+     * per-section detail hands off to giant zone labels. Reduced-motion hard-swaps.
+     * Section/zone labels are scale-compensated to hold a roughly constant screen size.
+     */
+    private applySectionLod;
+    /** Set a centred label's world fontSize (for a target screen px) and re-anchor it. */
+    private sizeLabel;
+    /**
+     * Map a container-relative screen point back to world coords. Inverts the
+     * stage (scale/pos) and, in iso view, the iso affine — so screen-space taps
+     * test against the flat world outlines/geometry. Identity-equivalent at isoT=0.
+     */
+    private screenToWorld;
+    /** Section id under a container-relative screen point, or null (Slice 5 tap-to-zoom). */
+    sectionAt(clientPoint: {
+        x: number;
+        y: number;
+    }): string | null;
+    /** Seat ids belonging to a section (Slice 5 section-summary card). */
+    sectionMembers(id: string): string[];
+    private addCentredLabel;
+    private isSelectable;
+    private toggleSeat;
+    private setSelected;
+    private wireInteraction;
+    private toLocal;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerEnd;
+    /**
+     * Min is chart-relative (never lose the room); max is absolute so seats
+     * reach a readable size on any chart, however large the venue.
+     */
+    private zoomBounds;
+    /** Zoom so `clientPoint` (stage-relative px) stays fixed under the cursor. */
+    private zoomAbout;
+    /** Zoom + pan so world-rect `b` fills the viewport (with a small margin). */
+    private zoomToBounds;
+    /** Recompute LOD (cache/labels) after any pan/zoom settles. */
+    private afterViewChange;
+    /** rAF-coalesced `onViewChange` — at most one host callback per animation frame. */
+    private scheduleViewChange;
+    private updateLOD;
+    private cacheSeatLayer;
+    private updateLabels;
+    private handleResize;
+    private startFpsLoop;
+}
+declare function createRenderer(container: HTMLDivElement, opts?: RendererOptions): ISeatmapRenderer;
+
+interface PickerSeat {
+    id: string;
+    label: string;
+    categoryKey: string;
+    price: number;
+}
+interface HoldConflict {
+    label: string;
+    reason: string;
+}
+/** An open hold — its id, the labels it covers, and the server's expiry time (ms epoch). */
+interface HoldInfo {
+    holdId: string;
+    labels: string[];
+    expiresAt: number;
+}
+interface HoldResponse {
+    holdId: string;
+    expiresAt: number;
+}
+interface BestAvailableResponse extends HoldResponse {
+    labels: string[];
+}
+/** Swappable public-surface transport (SDK PubApi or a dashboard `api.pub.*` adapter). */
+interface PickerTransport {
+    chart(key: string): Promise<{
+        doc: ChartDoc;
+        event: {
+            key: string;
+            name: string;
+            salesClosed?: boolean;
+            venue?: string | null;
+            startsAt?: number | null;
+        };
+    }>;
+    objects(key: string): Promise<{
+        seats: Record<string, string>;
+    }>;
+    hold(key: string, labels: string[]): Promise<HoldResponse>;
+    bestAvailable(key: string, qty: number, categoryKey?: string): Promise<BestAvailableResponse>;
+    release(key: string, labels: string[], holdId: string): Promise<unknown>;
+    /** Optional — the SDK omits booking (it hands the holdId to the host page). */
+    book?(key: string, labels: string[], holdId: string, bookingRef: string): Promise<unknown>;
+    socketUrl(key: string): string;
+}
+interface PickerCallbacks extends RendererCallbacks {
+    /** Selection changed (manual clicks or a server best-available pick). */
+    onSelectionChange?: (seats: PickerSeat[]) => void;
+    /** A hold opened (manual hold or best-available). */
+    onHold?: (hold: HoldInfo) => void;
+    /** The open hold expired server-side (the controller has already released it). */
+    onHoldExpired?: () => void;
+    /** A booking completed with this ref. */
+    onBook?: (bookingRef: string) => void;
+    /** Any live seat-status change arrived (delta or snapshot) — e.g. to recount "N left". */
+    onStatusChange?: () => void;
+    /** The server declared the event closed (a 409 event_closed). */
+    onSalesClosed?: () => void;
+    onError?: (err: unknown) => void;
+}
+interface PickerOptions extends PickerCallbacks {
+    transport: PickerTransport;
+    eventKey: string;
+    maxSelection?: number;
+    /** Renderer confirm-card mode (host shows a confirm popover instead of instant cart add). */
+    confirmSelection?: boolean;
+    /** Flash a pulse when a seat we didn't touch goes free→taken (live-activity cue). */
+    flashOnLiveChange?: boolean;
+}
+declare class PickerController {
+    private readonly opts;
+    private readonly api;
+    private readonly key;
+    private readonly maxSelection;
+    private renderer;
+    private _doc;
+    /** label ⇄ id maps — backend speaks labels, the engine speaks ids. */
+    private labelToId;
+    private labelToSeat;
+    private allIds;
+    private ws;
+    private reconnectTimer;
+    private attempt;
+    private closed;
+    private hold_;
+    private expiryTimer;
+    constructor(options: PickerOptions);
+    get doc(): ChartDoc | null;
+    currentHold(): HoldInfo | null;
+    getRenderer(): ISeatmapRenderer | null;
+    seatByLabel(label: string): ExpandedSeat | undefined;
+    idForLabel(label: string): string | undefined;
+    /** Fetch chart, build label maps, mount the renderer, seed statuses, go live. */
+    render(host: HTMLDivElement): Promise<{
+        doc: ChartDoc;
+        salesClosed: boolean;
+        eventName: string;
+        venue?: string | null;
+        startsAt?: number | null;
+    } | null>;
+    getSelection(): PickerSeat[];
+    clearSelection(): void;
+    deselect(ids: string[]): void;
+    /**
+     * Hold the current selection (or a given label set). The controller does the
+     * renderer/hold side (409 → deselect + repaint the taken seats held) and then
+     * re-throws so the caller can choose the banner copy. Returns null only when
+     * there's nothing to hold.
+     */
+    hold(labelsArg?: string[]): Promise<HoldInfo | null>;
+    /** Server-picks `qty` best free seats and holds them atomically. Throws on failure. */
+    bestAvailable(qty: number, categoryKey?: string): Promise<HoldInfo | null>;
+    /**
+     * Complete a booking. Requires a transport that supports book() (the SDK
+     * deliberately does not). `bookingRef` MUST be a real reference from the caller.
+     * `labelsArg` lets the caller book its own cart (the live page's confirm-flow
+     * cart can hold best-available seats that aren't in the renderer selection);
+     * defaults to the renderer selection. Reuses an existing exact-match hold, else
+     * holds first. Returns the labels booked, or null on failure (conflicts painted).
+     */
+    book(bookingRef: string, labelsArg?: string[]): Promise<string[] | null>;
+    /** Release the whole open hold (if any), repaint those seats free. */
+    release(): Promise<void>;
+    /**
+     * Release just some labels from the open hold, keeping the rest held (used when
+     * a buyer removes one seat chip). Clears the hold entirely once it empties.
+     */
+    releaseLabels(labels: string[]): Promise<void>;
+    setStatus(ids: string[], status: SeatStatus): void;
+    getStatus(id: string): SeatStatus | undefined;
+    flashSeat(id: string, color?: string): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    zoomToFit(): void;
+    worldToScreen(p: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    setAccessibilityFilter(types: string[] | null): void;
+    destroy(): void;
+    private toSeat;
+    private priceFor;
+    private emitSelectionChange;
+    private emitError;
+    private holdCovers;
+    private handle409Conflicts;
+    /** Set the open hold + (re)arm the server-authoritative expiry timer. */
+    private setHold;
+    private clearHold;
+    private onHoldExpired;
+    private applySeatsMap;
+    private resnapshot;
+    private connect;
+    private scheduleReconnect;
+}
+
+export { ACCESSIBILITY_TYPES, type AccessibilityMeta, type AccessibilityType, type BoothObject, CHART_STORAGE_KEY, type Category, type ChartDoc, type ChartObject, type ChartTheme, type ExpandedSeat, type GAAreaObject, type HoldConflict, type HoldInfo, type ISeatmapRenderer, type PickerCallbacks, PickerController, type PickerOptions, type PickerSeat, type PickerTransport, type Point, type RendererCallbacks, type RendererOptions, type RowObject, type RowSeatSlot, type SeatOverride, type SeatStatus, SeatmapRenderer, type SectionObject, type SelectionLayer, type ShapeObject, type TableObject, type TextObject, type ZoneDef, accessibilityMeta, chartBounds, createRenderer, expandBooth, expandChart, expandRow, expandRowSlots, expandTable, layerOf, objectCenter, pointInPolygon };