@seatlayer/js 0.36.1 → 0.36.3

package/dist/index.d.ts

@@ -605,7 +605,7 @@ interface RealtimeSink {
         activeHolds: number;
     }): void;
 }
-interface SubscribeTicket {
+interface SubscribeTicket$1 {
     ticket?: string;
     /** Exactly what to hand `new WebSocket(url, protocols)`, per protocol doc §3. */
     protocols?: string[];
@@ -616,7 +616,7 @@ interface BuyerRealtimeOptions {
     sink: RealtimeSink;
     /** Mint a one-use ticket for THIS connection attempt. Returns null for the
      *  anonymous public case (no ticket needed). Throwing stops the client. */
-    mintTicket?: () => Promise<SubscribeTicket | null>;
+    mintTicket?: () => Promise<SubscribeTicket$1 | null>;
     /** Typed access states. 4401 arrives here as `revoked`. */
     onAccessUnavailable?: (event: BuyerAccessUnavailableEvent) => void;
     /** Test seam. Defaults to the global WebSocket. */
@@ -1830,9 +1830,23 @@ declare function attachPickerFrame(iframe: HTMLIFrameElement, opts?: AttachPicke
  *
  * Spec: sales-channels-product-ux-spec §8.4–8.5.
  */
-/** Public sale is a built-in pseudo-channel; the server uses '' as its id. */
-declare const PUBLIC_CHANNEL_ID = "";
+/**
+ * Public sale is a built-in pseudo-channel. The server's sentinel for it is the
+ * literal string `'public'` — it is what `GET /channels` returns as
+ * `publicSale.id`, what `GET /channels/allocation` reports for an unallocated
+ * unit, and what `POST /channels/assignments` accepts (alongside `null`) as the
+ * target meaning "send these back to public sale".
+ *
+ * This constant was `''` until 2026-08-02, which silently made every public unit
+ * look like an unknown PRIVATE channel to `planAssignment` and `markerOf` — the
+ * cause of the Review sheet's phantom "moved out of another channel" line and
+ * the rail's "?" marker. Keep it byte-identical to the server's
+ * `eventChannels.PUBLIC_CHANNEL_ID`.
+ */
+declare const PUBLIC_CHANNEL_ID = "public";
 declare const PUBLIC_CHANNEL_NAME = "Public sale";
+/** True for every spelling of "public sale" a worker may hand us. */
+declare function isPublicChannelId(id: string | null | undefined): boolean;
 type ChannelState = 'active' | 'paused' | 'archived';
 /** Physical inventory status, as the manage surface speaks it. */
 type ChannelSeatStatus = 'free' | 'held' | 'booked' | 'blocked';
@@ -1873,7 +1887,9 @@ interface ChannelRecord {
     access?: ChannelAccessSummary | null;
 }
 interface PublicSaleChannel {
-    id: typeof PUBLIC_CHANNEL_ID;
+    /** `'public'` on every shipped worker; typed loosely so an older build that
+     *  still answers `''` is normalised rather than rejected. */
+    id: string;
     name: string;
     state: 'active';
     counts: ChannelCounts;
@@ -1920,6 +1936,16 @@ interface ArchiveBlockedDetails {
     latestHoldExpiresAt?: number | null;
     retryAfterMs?: number;
 }
+/**
+ * Clamp any marker text down to the ONE uppercase character every surface draws.
+ *
+ * The server stores `marker` as free text (it only length-caps it), so a channel
+ * created outside this widget can carry "star" or "VIP". The comp's marker chip
+ * is a single glyph: taking two characters ("ST") overflows the 22px chip and
+ * stops reading as a letter. Non-letter leading characters (an emoji, a digit,
+ * punctuation) are skipped in favour of the first real letter.
+ */
+declare function markerLetter(raw: string | null | undefined, fallback: string): string;
 /**
  * Suggest a marker for a new channel: the first letter of its name when that
  * letter is still free, otherwise the next unused letter. Deterministic so the
@@ -2003,6 +2029,100 @@ declare function retryAfterCopy(details: ArchiveBlockedDetails | null | undefine
 declare function accessLine(access: ChannelAccessSummary | null | undefined): string;
 /** Plain-language label for the access-intent control. */
 declare function accessIntentLabel(intent: ChannelAccessIntent): string;
+/** Lifecycle the server stores. `rotated` means a newer link replaced this one. */
+type AccessLinkState = 'active' | 'revoked' | 'rotated';
+/** What the organizer surface renders: `state`, unless an active link has run
+ *  out of time or out of redemptions. Never a capability, never a hash. */
+type AccessLinkStatus = AccessLinkState | 'expired' | 'exhausted';
+/**
+ * One hosted link, exactly as `GET …/access-links` projects it.
+ *
+ * There is deliberately NO `url` and NO `capability` field here — the listing
+ * route does not return them, no other route returns them, and this type must
+ * not tempt a caller into believing otherwise. The secret exists in exactly one
+ * place for exactly one moment: the create/rotate response (`AccessLinkReveal`).
+ */
+interface AccessLinkRecord {
+    id: string;
+    channelId: string;
+    label: string | null;
+    includePublic: boolean;
+    expiresAt: number;
+    maxRedemptions: number;
+    redemptions: number;
+    /** Guest-weighted per-buyer ceiling handed to every session this link mints. */
+    maxQuantity: number;
+    sessionTtlSeconds: number;
+    state: AccessLinkState;
+    status: AccessLinkStatus;
+    createdAt: number;
+    createdBy: string | null;
+    revokedAt: number | null;
+    lastRedeemedAt: number | null;
+    /** Rotation lineage: the link this replaced, and the one that replaced it. */
+    rotatedFrom: string | null;
+    rotatedTo: string | null;
+}
+/** A listed link, with the live session count the rotate dialog needs to state
+ *  "N buyers got in with this link and still have access". */
+interface AccessLinkStatusRecord extends AccessLinkRecord {
+    activeSessions?: number;
+}
+/**
+ * The ONE-TIME reveal. `url` and `capability` are on the wire exactly once, in
+ * the create/rotate response, and are unrecoverable afterwards: SeatLayer stores
+ * only a hash. Nothing may persist this — see `ChannelsMode.revealLink`.
+ */
+interface AccessLinkReveal {
+    link: AccessLinkRecord;
+    url: string;
+    capability: string;
+    revealedOnce: true;
+    /** Rotation only: the link that just stopped working, and how many live buyer
+     *  sessions from it were ended (0 when the organizer let them finish). */
+    previous?: AccessLinkRecord;
+    endedSessions?: number;
+}
+/**
+ * Owner-set defaults for a new link. Expiry is NOT here: "when the event starts"
+ * is the server's own default (it knows `starts_at`; the cockpit does not), so
+ * the create form expresses that choice by omitting `expiresAt` entirely rather
+ * than by guessing a timestamp the server would then have to correct.
+ */
+declare const ACCESS_LINK_DEFAULTS: {
+    readonly maxRedemptions: 100;
+    readonly maxQuantity: 4;
+};
+/** Plain-language state badge for a hosted link (§9: no internal vocabulary). */
+declare function accessLinkBadge(link: Pick<AccessLinkRecord, 'status' | 'state'>): {
+    text: string;
+    kind: 'active' | 'paused' | 'archived';
+};
+/** Only an `active` link can be rotated or revoked; the server agrees (409
+ *  `access_link_not_active`), so the buttons are absent rather than failing. */
+declare function accessLinkIsLive(link: Pick<AccessLinkRecord, 'status' | 'state'>): boolean;
+/**
+ * The policy an organizer is agreeing to, in one list. Used by BOTH the reveal
+ * (what you just created) and the status card (what is live), so the two can
+ * never drift into describing the same link differently.
+ */
+declare function accessLinkPolicyLines(link: AccessLinkRecord): Array<{
+    k: string;
+    v: string;
+}>;
+/**
+ * Plain language for a refused hosted-link call.
+ *
+ * The PLATFORM BOUNDS live on the server (60s–180d expiry, 1–10 000 redemptions,
+ * 1–100 seats per buyer, 20 live links per channel) and the server states them
+ * in `message`. We surface that sentence rather than re-encoding the numbers
+ * here, so the client can never disagree with the rule it is reporting.
+ */
+declare function accessLinkErrorCopy(err: {
+    code?: string;
+    serverMessage?: string;
+    status?: number;
+} | null | undefined): string;
 /**
  * The chart-update refusal `channel_assignment_would_drop` (409) deliberately
  * mirrors the Apply skipped buckets, so ONE review component renders both.
@@ -2037,8 +2157,13 @@ declare function stateBadge(state: ChannelState | 'builtin'): string;
  *     cookie-CSRF gate, so no extra client header is needed.
  *   - `credentials: 'omit'` — there is no session cookie; the CMS runs
  *     cross-origin. The worker's credentialed CORS still echoes the CMS origin.
- *   - Realtime read (`/pub/events/:key/subscribe`, `/objects`, `/chart`) is
- *     PUBLIC (wildcard CORS, no token) — the live board subscribes with no auth.
+ *   - `/pub/events/:key/chart` stays public: geometry is the same map buyers
+ *     see. The seat STATE reads are not. `/pub/.../objects` and an unticketed
+ *     `/pub/.../subscribe` both answer with the BUYER projection, which shows
+ *     inventory the caller may not buy as a neutral `blocked` — so an organizer
+ *     reading them sees its own channel allocations as blocked seats. Both now
+ *     go through the token: `/v1/events/:key/objects` for the snapshot, and a
+ *     `/v1/events/:key/subscribe-tickets` mint for the socket's scope.
  *
  * `box-book` is intentionally omitted for M1 (box office ships in M2, and the
  * route is still session-only server-side).
@@ -2112,10 +2237,17 @@ declare class ManageApiError extends Error {
      * `channel_assignment_conflict` carries the current assignmentVersion.
      */
     details?: Record<string, unknown>;
+    /**
+     * The server's own human sentence, when it sent one. `message` is the machine
+     * code (that is what `error` carries), so a UI that wants to state a PLATFORM
+     * RULE — "redemptions must be between 1 and 10 000" — reads this instead of
+     * re-encoding the bound locally and risking disagreement with the server.
+     */
+    serverMessage?: string;
     constructor(status: number, message: string, code?: string, conflicts?: {
         label: string;
         reason?: string;
-    }[], details?: Record<string, unknown>);
+    }[], details?: Record<string, unknown>, serverMessage?: string);
 }
 interface ReportByStatus {
     free: number;
@@ -2219,6 +2351,18 @@ interface LogPage {
     entries: LogEntry[];
     nextBefore: number | null;
 }
+/**
+ * A one-use WebSocket subscribe ticket. `protocols` is exactly what to hand
+ * `new WebSocket(url, protocols)` — the ticket rides in `Sec-WebSocket-Protocol`
+ * because a browser socket cannot carry an Authorization header and a bearer
+ * must never travel in a URL.
+ */
+interface SubscribeTicket {
+    ticket: string;
+    expiresAt: number;
+    protocol: string;
+    protocols: string[];
+}
 interface PubObjectsResult {
     /** Every non-free seat's status keyed by label (free seats omitted). */
     seats: Record<string, string>;
@@ -2250,8 +2394,32 @@ declare class ManageApi {
     setToken(token: string): void;
     private auth;
     private pub;
+    /** The chart geometry. Genuinely public — it is the same map buyers see. */
     chart(key: string): Promise<PubChartResult>;
+    /**
+     * The ORGANIZER's seat map: physical state, token-authed.
+     *
+     * This used to read `/pub/events/:key/objects` with no credential, which
+     * answers with the BUYER projection — every unit the caller may not buy
+     * collapses to a neutral `blocked`. An anonymous caller may buy only Public
+     * sale inventory, so the cockpit rendered every channel-allocated seat as
+     * blocked and then computed its KPIs, sell-through and (worse) its
+     * block/unblock target sets from that. `/v1/events/:key/objects` returns the
+     * unprojected snapshot the control-room read model already trusts.
+     */
     objects(key: string): Promise<PubObjectsResult>;
+    /**
+     * Exchange the manage token for a one-use organizer socket ticket.
+     *
+     * A browser `WebSocket` cannot send an Authorization header, so the socket's
+     * scope is established here, over ordinary HTTPS. Without it the DO treats a
+     * manager socket as an anonymous public buyer and projects its deltas — so a
+     * hold inside a private allocation is structurally suppressed and the map
+     * drifts away from the truth `objects()` just established.
+     *
+     * Tickets are single-redemption and expire in ~30s: mint one per connect.
+     */
+    subscribeTicket(key: string): Promise<SubscribeTicket>;
     socketUrl(key: string): string;
     /** Take FREE seats off sale in one batched call. Optional `releaseAt` (epoch
      *  ms, future) auto-returns them to sale; `reason` tags the block (M3 uses it).
@@ -2370,6 +2538,53 @@ declare class ManageApi {
         ok: true;
         channel: ChannelRecord;
     }>;
+    /**
+     * Mint a hosted access link. The 201 is the ONE and ONLY time `url` and
+     * `capability` exist outside the buyer's browser — SeatLayer keeps a hash, so
+     * there is no route, cache, or support escalation that can produce this string
+     * again. Callers must reveal it immediately and then let it go.
+     *
+     * Every omitted field takes the server's default: expiry = when the event
+     * starts, 100 redemptions, 4 seats per buyer, this channel's allocation only.
+     * Platform bounds are enforced server-side and reported as 422 with the rule
+     * spelled out in `ManageApiError.serverMessage`.
+     *
+     * Side effect by design: this also declares the channel's access intent as
+     * `hosted_link`, so the rail stops saying "no buyer access configured".
+     */
+    createAccessLink(key: string, channelId: string, input?: {
+        label?: string | null;
+        /** Absolute epoch ms. Omit for "when the event starts". */
+        expiresAt?: number;
+        maxRedemptions?: number;
+        maxQuantity?: number;
+        includePublic?: boolean;
+    }): Promise<AccessLinkReveal>;
+    /** Status only — label, expiry, redemptions, per-buyer cap, lineage, and the
+     *  live session count. Never the url, never the capability. Needs `:view`. */
+    accessLinks(key: string, channelId: string): Promise<{
+        links: AccessLinkStatusRecord[];
+    }>;
+    /**
+     * Rotate — the ONLY recovery for a link nobody kept. The old URL stops opening
+     * immediately and the response is a fresh one-time reveal.
+     *
+     * `endActiveSessions` is REQUIRED, not defaulted: the organizer must say
+     * whether buyers already inside finish their checkout or lose access now. The
+     * server answers 422 `end_active_sessions_required` if it is omitted, and that
+     * refusal is correct — a UI must not pick either branch on their behalf.
+     */
+    rotateAccessLink(key: string, channelId: string, linkId: string, endActiveSessions: boolean): Promise<AccessLinkReveal & {
+        previous: AccessLinkRecord;
+        endedSessions: number;
+    }>;
+    /** Revoke. The link stops opening immediately; `endActiveSessions` decides
+     *  whether the buyers already inside keep their sessions. */
+    revokeAccessLink(key: string, channelId: string, linkId: string, endActiveSessions?: boolean): Promise<{
+        ok: true;
+        link: AccessLinkRecord;
+        endedSessions: number;
+    }>;
     report(key: string): Promise<ReportResult>;
     controlRoom(key: string, windowMinutes?: number): Promise<ControlRoomSnapshot>;
     log(key: string, opts?: {
@@ -2648,10 +2863,33 @@ declare class SeatManager {
     private updateRendererInteraction;
     private handleSeatSelect;
     private repaintAll;
+    /**
+     * Open the cockpit's realtime socket AS THE ORGANIZER.
+     *
+     * The scope has to be established before the upgrade, because a browser
+     * `WebSocket` cannot send an Authorization header: the manage token is traded
+     * over HTTPS for a one-use ticket which rides in `Sec-WebSocket-Protocol`.
+     * Without it the server treats this socket as an anonymous public buyer and
+     * projects its deltas, so any change inside a private channel allocation is
+     * structurally suppressed and the map silently drifts.
+     *
+     * If the mint fails (an expired token, a worker that predates the route) we
+     * still connect unticketed rather than going dark — the public-sale stream is
+     * worth having, and every `resnapshot()` re-establishes physical truth from
+     * the authenticated HTTP read.
+     */
     private connect;
     private scheduleReconnect;
     private onMessage;
     private resnapshot;
+    /**
+     * Replace the whole seat model.
+     *
+     * `fallback` is the compact frame's modal status: those snapshots list only
+     * the seats that DIFFER from it, so every other known label takes it. Without
+     * this the omitted majority would silently fall back to `free` — fine when
+     * the mode really is free, wrong the moment it is not.
+     */
     private applySnapshot;
     /** Optimistic local write shared by organizer actions. Paint and tally once,
      * even when an arena-sized operation changes hundreds of seats. */
@@ -2828,6 +3066,26 @@ interface ChannelsClient {
         ok: true;
         channel: ChannelRecord;
     }>;
+    /** 201 with the ONE-TIME reveal. Every omitted field takes the server default
+     *  (expiry = event start, 100 redemptions, 4 seats per buyer). */
+    createAccessLink(key: string, channelId: string, input: {
+        label?: string | null;
+        expiresAt?: number;
+        maxRedemptions?: number;
+        maxQuantity?: number;
+        includePublic?: boolean;
+    }): Promise<AccessLinkReveal>;
+    /** Status only. This response has no url and no capability, by contract. */
+    accessLinks(key: string, channelId: string): Promise<{
+        links: AccessLinkStatusRecord[];
+    }>;
+    /** `endActiveSessions` is required — the server 422s without it, deliberately. */
+    rotateAccessLink(key: string, channelId: string, linkId: string, endActiveSessions: boolean): Promise<AccessLinkReveal>;
+    revokeAccessLink(key: string, channelId: string, linkId: string, endActiveSessions?: boolean): Promise<{
+        ok: true;
+        link: unknown;
+        endedSessions: number;
+    }>;
 }
 interface ChannelsCapabilities {
     view: boolean;
@@ -2906,6 +3164,15 @@ declare class ChannelsMode {
     private dialog;
     private detent;
     private seatListLimit;
+    /**
+     * Hosted-link STATUS for the channel whose detail panel is open. This is the
+     * listing projection — it carries no url and no capability, because no route
+     * returns one. `unsupported` is the honest answer for a worker that predates
+     * M8, exactly like the buyer-preview probe.
+     */
+    private links;
+    private linksChannelId;
+    private linksState;
     private previewAudience;
     private previewIncludePublic;
     private previewProjection;
@@ -2989,6 +3256,23 @@ declare class ChannelsMode {
     private listRailHtml;
     private selectionRailHtml;
     private detailRailHtml;
+    /**
+     * Read the status projection for the open channel. Never paints — the caller
+     * decides when the rail repaints, so a poll-driven reload does not fight a
+     * user-driven one. A worker without M8 answers 404/405 and gets the honest
+     * "needs a newer server" line rather than an error toast.
+     */
+    private loadLinks;
+    /**
+     * The hosted-link section of the detail panel.
+     *
+     * STATUS ONLY, by design (comp 06 `hosted`): label, state, expiry,
+     * redemptions, seats per buyer, live sessions. There is no Copy control here
+     * and no field to hang one on — the URL was shown once at creation and cannot
+     * be produced again. Rotation is the recovery path, and it says so.
+     */
+    private hostedLinksHtml;
+    private linkCardHtml;
     private previewRailHtml;
     private paintSelection;
     private wireRail;
@@ -3029,6 +3313,43 @@ declare class ChannelsMode {
      * per-section select actions.
      */
     private renderSeatListDialog;
+    private reloadLinks;
+    private linkById;
+    /**
+     * Create. The three policy fields carry the owner's defaults and every one of
+     * them is editable; the PLATFORM bounds (60s–180d, 1–10 000, 1–100, 20 live
+     * links) are the server's to enforce and the server's to explain, so this form
+     * checks only that a number is a number and surfaces the server's sentence for
+     * everything else.
+     */
+    private renderLinkCreateDialog;
+    private createLink;
+    /**
+     * The ONE-TIME reveal.
+     *
+     * Three things make this unrecoverable rather than merely "not shown twice":
+     *
+     *   1. `url` is a local const. It is never assigned to a field on this class,
+     *      never handed to the host, never put in a `DialogState`.
+     *   2. `this.dialog` is cleared FIRST, so `renderDialog()` — the only function
+     *      that rebuilds a sheet — has nothing to rebuild this one from.
+     *   3. The string exists in exactly one DOM node inside the scrim. Dismissing
+     *      the dialog removes the scrim, and the closure goes with it.
+     *
+     * The server holds only a hash, so even a compromised client cannot ask for it
+     * again. Rotation is the recovery path, and the copy says so.
+     */
+    private revealLink;
+    /**
+     * Rotate. The organizer must SAY what happens to the buyers already inside —
+     * the confirm stays disabled until one of the two choices is picked, because
+     * the gentle branch and the destructive branch are both real decisions and the
+     * server refuses (422 `end_active_sessions_required`) to guess either.
+     */
+    private renderLinkRotateDialog;
+    private rotateLink;
+    private renderLinkRevokeDialog;
+    private revokeLink;
     private applySheetClasses;
     private cycleDetent;
     /** Back/Close from the full detent returns to the previous one and keeps the
@@ -3036,4 +3357,4 @@ declare class ChannelsMode {
     handleBack(): boolean;
 }
 
-export { ApiError, type ArchiveBlockedDetails, type AssignmentBuckets, type AssignmentDropDetails, type AssignmentResult, type AttachPickerFrameOptions, type BestAvailableResult, type BucketRow, BuyerAccessContext, type BuyerAccessExpiredEvent, type BuyerAccessRefreshReason, type BuyerAccessToken, type BuyerAccessTokenProvider, BuyerAccessUnavailableError, type BuyerAccessUnavailableEvent, type BuyerAccessUnavailableReason, BuyerRealtimeClient, type BuyerRealtimeOptions, type ChannelAccessIntent, type ChannelAccessSummary, type ChannelAllocationPage, type ChannelAuditEntry, type ChannelAuditPage, type ChannelCounts, type ChannelListResult, type ChannelPreviewProjection, type ChannelRecord, type ChannelSeatStatus, type ChannelState, type ChannelsCapabilities, type ChannelsClient, ChannelsMode, type ChannelsModeHost, type ChannelsSeatView, type CheckoutHandoff, type CheckoutLineItem, type ControlRoomActivityEntry, type ControlRoomSectionMetric, type ControlRoomSnapshot, EmbeddedDesigner, type EmbeddedDesignerEventType, type EmbeddedDesignerMessage, type EmbeddedDesignerOptions, type GAAreaAvailability, type HoldConflict, type HoldLineItem, type HoldResult, type LogEntry, type LogPage, ManageApi, ManageApiError, PUBLIC_CHANNEL_ID, PUBLIC_CHANNEL_NAME, type Projection, type PubApiOptions, type RealtimeSink, type ReportByStatus, type ReportCategoryMeta, type ReportCategoryRow, type ReportResult, type ResumedHoldResult, SeatManager, type SeatManagerActionResult, type SeatManagerActivity, type SeatManagerCapability, type SeatManagerMode, type SeatManagerOptions, type SeatManagerTallies, SeatPicker, type SeatPickerOptions, type SeatPickerTheme, SeatingChart, type SeatingChartOptions, type SelectedObjectUnavailableEvent, type SelectedSeat, type SelectionSourceRow, type StatusChange, type SubscribeTicket, accessIntentLabel, accessLine, attachPickerFrame, bucketRows, bucketRowsHtml, createBuyerAccessContext, createControllerSink, dropReviewRows, markerOf, mutationCount, needsMoveConfirmation, planAssignment, retryAfterCopy, selectionSources, stateBadge, suggestMarker };
+export { ACCESS_LINK_DEFAULTS, type AccessLinkRecord, type AccessLinkReveal, type AccessLinkState, type AccessLinkStatus, type AccessLinkStatusRecord, ApiError, type ArchiveBlockedDetails, type AssignmentBuckets, type AssignmentDropDetails, type AssignmentResult, type AttachPickerFrameOptions, type BestAvailableResult, type BucketRow, BuyerAccessContext, type BuyerAccessExpiredEvent, type BuyerAccessRefreshReason, type BuyerAccessToken, type BuyerAccessTokenProvider, BuyerAccessUnavailableError, type BuyerAccessUnavailableEvent, type BuyerAccessUnavailableReason, BuyerRealtimeClient, type BuyerRealtimeOptions, type ChannelAccessIntent, type ChannelAccessSummary, type ChannelAllocationPage, type ChannelAuditEntry, type ChannelAuditPage, type ChannelCounts, type ChannelListResult, type ChannelPreviewProjection, type ChannelRecord, type ChannelSeatStatus, type ChannelState, type ChannelsCapabilities, type ChannelsClient, ChannelsMode, type ChannelsModeHost, type ChannelsSeatView, type CheckoutHandoff, type CheckoutLineItem, type ControlRoomActivityEntry, type ControlRoomSectionMetric, type ControlRoomSnapshot, EmbeddedDesigner, type EmbeddedDesignerEventType, type EmbeddedDesignerMessage, type EmbeddedDesignerOptions, type GAAreaAvailability, type HoldConflict, type HoldLineItem, type HoldResult, type LogEntry, type LogPage, ManageApi, ManageApiError, PUBLIC_CHANNEL_ID, PUBLIC_CHANNEL_NAME, type Projection, type PubApiOptions, type RealtimeSink, type ReportByStatus, type ReportCategoryMeta, type ReportCategoryRow, type ReportResult, type ResumedHoldResult, SeatManager, type SeatManagerActionResult, type SeatManagerActivity, type SeatManagerCapability, type SeatManagerMode, type SeatManagerOptions, type SeatManagerTallies, SeatPicker, type SeatPickerOptions, type SeatPickerTheme, SeatingChart, type SeatingChartOptions, type SelectedObjectUnavailableEvent, type SelectedSeat, type SelectionSourceRow, type StatusChange, type SubscribeTicket$1 as SubscribeTicket, accessIntentLabel, accessLine, accessLinkBadge, accessLinkErrorCopy, accessLinkIsLive, accessLinkPolicyLines, attachPickerFrame, bucketRows, bucketRowsHtml, createBuyerAccessContext, createControllerSink, dropReviewRows, isPublicChannelId, markerLetter, markerOf, mutationCount, needsMoveConfirmation, planAssignment, retryAfterCopy, selectionSources, stateBadge, suggestMarker };