@seatschart/angular 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SeatsChart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,148 @@
-# Temporary Holding Version
+# @seatschart/angular
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Angular standalone components for SeatsChart: the buyer seat chart, the Event Manager and the map designer. They are
+thin wrappers over the script-tag host API of [`@seatschart/embed`](https://www.npmjs.com/package/@seatschart/embed)
+(`SeatsChart`, `SeatsChartEventManager`, `SeatsChartDesigner`): same options, seats.io-compatible callback names and
+the same commands. SSR-safe (Angular SSR / Universal): nothing touches `window` at import and the iframe is created
+in the browser only, after the view is ready.
+
+## Install
+
+```bash
+npm install @seatschart/angular @seatschart/embed
+```
+
+Angular 18 or newer (tested with the Angular 21 LTS). The package ships partially compiled (Ivy) components that the
+Angular CLI links into your app; it works with and without zone.js.
+
+## Buyer seat chart
+
+`token` is a short-lived buyer JWT minted by your server with the API key (`POST /api/viewer-tokens`). Never pass an
+API key or a secret to the browser.
+
+```ts
+import { Component, ViewChild } from "@angular/core";
+import { SeatChartComponent, type SeatChartPrompt } from "@seatschart/angular";
+import type { ChartObjectSelected, ChartSessionHold } from "@seatschart/embed";
+
+@Component({
+  selector: "app-seats",
+  imports: [SeatChartComponent],
+  template: `
+    <seatschart-chart
+      #chart
+      class="seat-map"
+      webBase="https://your-tenant.seatschart.com"
+      [event]="eventId"
+      [token]="jwt"
+      language="pt"
+      [height]="640"
+      [maxSelectedObjects]="maxSeats"
+      [objectColor]="{ byStatus: { locked: '#f59e0b' } }"
+      [settings3d]="{ lightPreset: 'exteriorSunset' }"
+      (chartRendered)="ready = true"
+      (objectSelected)="onSelected($event)"
+      (sessionHold)="onHold($event)"
+      (holdFailed)="error = $event.message"
+    />
+    <button type="button" (click)="chart.clearSelection()">Clear</button>
+    <button type="button" (click)="chart.selectBestAvailable({ number: 2, categories: ['VIP'] })">Best 2 VIP</button>
+  `,
+})
+export class SeatsComponent {
+  @ViewChild(SeatChartComponent) chart?: SeatChartComponent;
+  eventId = "EVENT_UUID";
+  jwt = "";
+  maxSeats = 4;
+  ready = false;
+  error = "";
+  cart: string[] = [];
+
+  onSelected(e: ChartObjectSelected): void {
+    this.cart = [...this.cart, e.label];
+  }
+  onHold(e: ChartSessionHold): void {
+    // Route to your payment step with e.holdToken + e.seatIds.
+  }
+  async viewFromSeat(label: string): Promise<void> {
+    await this.chart?.showViewFromSeat(label); // "3d" or "photo"
+  }
+}
+```
+
+- **Inputs** are the `SeatsChart` options of `@seatschart/embed` (`event`, `token`, `webBase`, `parentOrigin`,
+  `channel`, `channelKey(s)`, `holdToken`, `pricing`, `language`, `theme`, `defaultRenderer`, …) and every declarative
+  renderer option (`objectColor`, `objectLabel`, `tooltip`, `maxSelectedObjects`, `legend`, `filterControls`,
+  `settings3d`, …). The chart `style` option (`{ font, cornerRadius, buttonShape }`) is **`chartStyle`**: `class` and
+  `style` style the host element `<seatschart-chart>` (a block); `className` styles the iframe.
+- **Changes** (`ngOnChanges`) are compared by value — pass new object references, in-place mutations are not seen.
+  Declarative options and `pricing` are applied live with `changeConfig` (no reload); `height`, `title` and
+  `className` update the iframe in place; any other input re-renders the iframe and the hold session continues.
+- **Outputs**: every chart callback without `on`: `(objectSelected)`, `(objectClicked)`, `(holdSucceeded)`,
+  `(holdConfirmed)`, `(selectionInvalid)`, `(bestAvailableSelected)`, `(floorChanged)`, `(fullScreenOpened)`,
+  `(holdCreated)` (`SEATSCHART_RESERVATION_SUCCESS`), … with the `@seatschart/embed` payload as `$event`. Chart
+  messages run outside the Angular zone: only outputs you subscribe to trigger change detection.
+- **Host-drawn prompts**: subscribing to `(placesPrompt)`, `(ticketTypePrompt)` or `(placesWithTicketTypesPrompt)`
+  switches that viewer prompt to your page; `$event` is `{ params, confirm, cancel }` (`SeatChartPrompt<T>`).
+- **Commands** are component methods (`@ViewChild` or a template variable): every `SeatsChart` command —
+  `selectObjects`, `deselectObjects`, `clearSelection`, `trySelectObjects`, `selectBestAvailable`, `changeConfig`,
+  `setFilters`, `zoomToObjects`, `zoomToSection`, `goToFloor`, `showViewFromSeat`, `getHoldToken`,
+  `releaseHoldToken`, `exportImage`, … Each resolves once the chart rendered and rejects with `ChartCommandError`.
+  `chart` is the `SeatsChart` instance (`chart?.selectedObjects`, `chart?.holdToken` synchronously); `getIframe()`
+  and `rerender()` are there too.
+- **Cleanup**: `ngOnDestroy` removes the iframe and its message listener; pending commands reject.
+
+## Event Manager (back office)
+
+```ts
+import { EventManagerComponent } from "@seatschart/angular";
+
+@Component({
+  selector: "app-box-office",
+  imports: [EventManagerComponent],
+  template: `
+    <seatschart-event-manager #manager webBase="https://your-tenant.seatschart.com" [event]="eventId"
+      [token]="managerEmbedToken" mode="select" colorScheme="auto" [maxSelectedObjects]="8"
+      (selectionChanged)="cart = $event" (managerError)="error = $event.message" />
+    <button type="button" (click)="manager.setHighlightedObjects(['A-1'])">Highlight A-1</button>
+  `,
+})
+export class BoxOfficeComponent { /* … */ }
+```
+
+Selectability rules, `maxSelectedObjects`, `selectedObjects`, `order`, `filters`, `language` and `colorScheme`
+change live (`changeConfig`); `mode`, `event` or `token` re-render the iframe. Methods: every
+`SeatsChartEventManager` command (`listSelectedObjects`, `selectObjects`, `listOrderChanges`, `zoomToObjects`, …);
+`manager` is the instance. The seats.io `onError` callback is `(managerError)` (an output named `error` would also
+catch native DOM `error` events).
+
+## Designer
+
+```ts
+import { DesignerComponent } from "@seatschart/angular";
+
+@Component({
+  selector: "app-venue-editor",
+  imports: [DesignerComponent],
+  template: `
+    <seatschart-designer #designer webBase="https://your-tenant.seatschart.com" [token]="designerEmbedToken"
+      [chartId]="chartId" mode="safe" canvasColorScheme="dark"
+      (chartUpdated)="saved = true" (exitRequested)="close()" />
+    <button type="button" (click)="designer.publish('Summer layout')">Publish</button>
+  `,
+})
+export class VenueEditorComponent { /* … */ }
+```
+
+Without `chartId` the designer creates a chart (`(chartCreated)`). The Exit button shows only when something
+subscribes to `(exitRequested)`. Outputs emit the callback's event (`(chartUpdated)` gets `{ chartId, draftUpdatedAt,
+… }`); `onError` is `(designerError)`. `language`, `colorScheme`, `canvasColorScheme`, `mode` and `safeModeOptions`
+change live. Methods: `save()`, `publish(note?)`, `getState()`, `changeConfig()`; `designer?.chartId` is the chart
+being edited.
+
+## Documentation
+
+- [Embed guide](https://github.com/seatschart/seatschart-prod/blob/main/docs/locales/en/README.md) and
+  [Quickstart](https://github.com/seatschart/seatschart-prod/blob/main/docs/locales/en/QUICKSTART.md)
+- Every option, callback and command: `@seatschart/embed` (`SeatsChartConfig`, `SeatsChartEventManagerConfig`,
+  `SeatsChartDesignerConfig`).

package/dist/designer.component.d.ts

@@ -0,0 +1,62 @@
+import { type AfterViewInit, type EventEmitter, type OnChanges, type OnDestroy } from "@angular/core";
+import type { DesignerCallbacks, DesignerErrorInfo, SeatsChartDesigner, SeatsChartDesignerConfig } from "@seatschart/embed";
+import { type DesignerCallbackKey, type DesignerCommands, type DesignerConfigKey } from "./host-core.js";
+import { type CallbackOutputs } from "./outputs.js";
+import * as i0 from "@angular/core";
+/** `<seatschart-designer>` inputs: the `SeatsChartDesigner` config (seats.io `SeatingChartDesigner` names). */
+export type DesignerInputs = {
+    [K in DesignerConfigKey]?: SeatsChartDesignerConfig[K];
+};
+/**
+ * Every designer callback as an output, emitting the callback's event (`onChartUpdated(chartId, event)` →
+ * `(chartUpdated)` with `event`, which carries `chartId`). Subscribing to `(exitRequested)` shows the Exit button.
+ * `onError` is `(designerError)`: an output named like a DOM event would also catch native `error` events.
+ */
+export type DesignerOutputs = Omit<CallbackOutputs<DesignerCallbacks, DesignerCallbackKey>, "error"> & {
+    readonly designerError: EventEmitter<DesignerErrorInfo>;
+};
+declare const INPUTS: readonly ["webBase", "chartId", "chartKey", "token", "mode", "safeModeOptions", "features", "language", "colorScheme", "canvasColorScheme", "openDraftDrawing", "openLatestDrawing", "parentOrigin", "height", "title", "className", "timeoutMs"];
+declare const OUTPUTS: readonly ["designerRendered", "designerRenderingFailed", "chartCreated", "chartUpdated", "chartPublished", "exitRequested", "actionRefused", "designerError"];
+type Assert<T extends true> = T;
+type Same<A, B> = [Exclude<A, B> | Exclude<B, A>] extends [never] ? true : false;
+/** Compile-time guard: the literal lists name every designer option and callback. */
+export type DesignerMetadataCovered = [
+    Assert<Same<(typeof INPUTS)[number], keyof DesignerInputs>>,
+    Assert<Same<(typeof OUTPUTS)[number], keyof DesignerOutputs>>
+];
+/**
+ * `<seatschart-designer>`: the embedded SeatsChart map designer. Without `chartId` it creates a chart
+ * (`(chartCreated)`). `language`, `colorScheme`, `canvasColorScheme`, `mode` and `safeModeOptions` are applied live
+ * with `changeConfig`; other changes re-render the iframe. `save()`, `publish()`, `getState()` and `changeConfig()`
+ * are methods. `token` is a short-lived designer embed token from your backend — never a secret key.
+ */
+export declare class DesignerComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly host;
+    private readonly zone;
+    private readonly browser;
+    private readonly forwarders;
+    private readonly exit;
+    constructor();
+    /**
+     * The underlying `SeatsChartDesigner` (null before the view is ready, on the server and after destroy):
+     * `designer?.chartId` is the chart being edited (the created one when no `chartId` input was given).
+     */
+    get designer(): SeatsChartDesigner | null;
+    getIframe(): HTMLIFrameElement | null;
+    /** Re-create the iframe with the current inputs (keeps the chart created inside the designer). */
+    rerender(): void;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private config;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesignerComponent, "seatschart-designer", never, { "webBase": { "alias": "webBase"; "required": false; }; "chartId": { "alias": "chartId"; "required": false; }; "chartKey": { "alias": "chartKey"; "required": false; }; "token": { "alias": "token"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "safeModeOptions": { "alias": "safeModeOptions"; "required": false; }; "features": { "alias": "features"; "required": false; }; "language": { "alias": "language"; "required": false; }; "colorScheme": { "alias": "colorScheme"; "required": false; }; "canvasColorScheme": { "alias": "canvasColorScheme"; "required": false; }; "openDraftDrawing": { "alias": "openDraftDrawing"; "required": false; }; "openLatestDrawing": { "alias": "openLatestDrawing"; "required": false; }; "parentOrigin": { "alias": "parentOrigin"; "required": false; }; "height": { "alias": "height"; "required": false; }; "title": { "alias": "title"; "required": false; }; "className": { "alias": "className"; "required": false; }; "timeoutMs": { "alias": "timeoutMs"; "required": false; }; }, { "designerRendered": "designerRendered"; "designerRenderingFailed": "designerRenderingFailed"; "chartCreated": "chartCreated"; "chartUpdated": "chartUpdated"; "chartPublished": "chartPublished"; "exitRequested": "exitRequested"; "actionRefused": "actionRefused"; "designerError": "designerError"; }, never, never, true, never>;
+}
+export interface DesignerComponent extends DesignerInputs, DesignerOutputs, DesignerCommands {
+}
+/** `<seatschart-designer>` input names. */
+export declare const DESIGNER_INPUTS: readonly string[];
+/** `<seatschart-designer>` output names (`onError` → `designerError`). */
+export declare const DESIGNER_OUTPUTS: readonly string[];
+export {};
+//# sourceMappingURL=designer.component.d.ts.map

package/dist/designer.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"designer.component.d.ts","sourceRoot":"","sources":["../src/designer.component.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC5H,OAAO,EAML,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAA0D,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;;AAE5G,+GAA+G;AAC/G,MAAM,MAAM,cAAc,GAAG;KAAG,CAAC,IAAI,iBAAiB,CAAC,CAAC,EAAE,wBAAwB,CAAC,CAAC,CAAC;CAAE,CAAC;AAExF;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,EAAE,OAAO,CAAC,GAAG;IACrG,QAAQ,CAAC,aAAa,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAC;CACzD,CAAC;AAEF,QAAA,MAAM,MAAM,mPAIF,CAAC;AACX,QAAA,MAAM,OAAO,+JAGH,CAAC;AAGX,KAAK,MAAM,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAChC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AACjF,qFAAqF;AACrF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,cAAc,CAAC,CAAC;IAC3D,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,eAAe,CAAC,CAAC;CAC9D,CAAC;AAKF;;;;;GAKG;AACH,qBAUa,iBAAkB,YAAW,aAAa,EAAE,SAAS,EAAE,SAAS;IAC3E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+C;IACpE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAc;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAGnB;;IAQF;;;OAGG;IACH,IAAI,QAAQ,IAAI,kBAAkB,GAAG,IAAI,CAExC;IAED,SAAS,IAAI,iBAAiB,GAAG,IAAI;IAIrC,kGAAkG;IAClG,QAAQ,IAAI,IAAI;IAIhB,WAAW,IAAI,IAAI;IAKnB,eAAe,IAAI,IAAI;IAMvB,WAAW,IAAI,IAAI;IAInB,OAAO,CAAC,MAAM;yCAhDH,iBAAiB;2CAAjB,iBAAiB;CAwD7B;AAED,MAAM,WAAW,iBAAkB,SAAQ,cAAc,EAAE,eAAe,EAAE,gBAAgB;CAAG;AAY/F,2CAA2C;AAC3C,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAAW,CAAC;AACzD,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAAY,CAAC"}

package/dist/designer.component.js

@@ -0,0 +1,92 @@
+import { isPlatformBrowser } from "@angular/common";
+import { ChangeDetectionStrategy, Component, ElementRef, NgZone, PLATFORM_ID, inject, } from "@angular/core";
+import { DESIGNER_CALLBACKS, DESIGNER_COMMANDS, DESIGNER_KIND, EmbedBinding, runCommand, } from "./host-core.js";
+import { createOutputs, emitterOf, outputForwarders, pickInputs } from "./outputs.js";
+import * as i0 from "@angular/core";
+const INPUTS = [
+    "webBase", "chartId", "chartKey", "token", "mode", "safeModeOptions", "features", "language", "colorScheme",
+    "canvasColorScheme", "openDraftDrawing", "openLatestDrawing", "parentOrigin", "height", "title", "className",
+    "timeoutMs",
+];
+const OUTPUTS = [
+    "designerRendered", "designerRenderingFailed", "chartCreated", "chartUpdated", "chartPublished", "exitRequested",
+    "actionRefused", "designerError",
+];
+const RENAMES = { onError: "designerError" };
+const EVENT_CALLBACKS = DESIGNER_CALLBACKS.filter((key) => key !== "onExitRequested");
+const bindings = new WeakMap();
+/**
+ * `<seatschart-designer>`: the embedded SeatsChart map designer. Without `chartId` it creates a chart
+ * (`(chartCreated)`). `language`, `colorScheme`, `canvasColorScheme`, `mode` and `safeModeOptions` are applied live
+ * with `changeConfig`; other changes re-render the iframe. `save()`, `publish()`, `getState()` and `changeConfig()`
+ * are methods. `token` is a short-lived designer embed token from your backend — never a secret key.
+ */
+export class DesignerComponent {
+    constructor() {
+        this.host = inject(ElementRef);
+        this.zone = inject(NgZone);
+        this.browser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.exit = () => {
+            const emitter = emitterOf(this, "exitRequested");
+            if (emitter.observed)
+                this.zone.run(() => emitter.emit(undefined));
+        };
+        createOutputs(this, OUTPUTS);
+        bindings.set(this, new EmbedBinding(DESIGNER_KIND));
+        this.forwarders = outputForwarders(this, EVENT_CALLBACKS, this.zone, RENAMES);
+    }
+    /**
+     * The underlying `SeatsChartDesigner` (null before the view is ready, on the server and after destroy):
+     * `designer?.chartId` is the chart being edited (the created one when no `chartId` input was given).
+     */
+    get designer() {
+        return bindings.get(this)?.current ?? null;
+    }
+    getIframe() {
+        return this.designer?.getIframe() ?? null;
+    }
+    /** Re-create the iframe with the current inputs (keeps the chart created inside the designer). */
+    rerender() {
+        this.zone.runOutsideAngular(() => bindings.get(this)?.rerender());
+    }
+    ngOnChanges() {
+        const config = this.config();
+        this.zone.runOutsideAngular(() => bindings.get(this)?.update(config));
+    }
+    ngAfterViewInit() {
+        if (!this.browser)
+            return;
+        const config = this.config();
+        this.zone.runOutsideAngular(() => bindings.get(this)?.mount(this.host.nativeElement, config));
+    }
+    ngOnDestroy() {
+        bindings.get(this)?.destroy();
+    }
+    config() {
+        return {
+            ...pickInputs(this, INPUTS),
+            ...this.forwarders,
+            // A subscribed (exitRequested) shows the Exit button.
+            ...(emitterOf(this, "exitRequested").observed ? { onExitRequested: this.exit } : {}),
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: DesignerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.25", type: DesignerComponent, isStandalone: true, selector: "seatschart-designer", inputs: { webBase: "webBase", chartId: "chartId", chartKey: "chartKey", token: "token", mode: "mode", safeModeOptions: "safeModeOptions", features: "features", language: "language", colorScheme: "colorScheme", canvasColorScheme: "canvasColorScheme", openDraftDrawing: "openDraftDrawing", openLatestDrawing: "openLatestDrawing", parentOrigin: "parentOrigin", height: "height", title: "title", className: "className", timeoutMs: "timeoutMs" }, outputs: { designerRendered: "designerRendered", designerRenderingFailed: "designerRenderingFailed", chartCreated: "chartCreated", chartUpdated: "chartUpdated", chartPublished: "chartPublished", exitRequested: "exitRequested", actionRefused: "actionRefused", designerError: "designerError" }, host: { attributes: { "data-seatschart-designer": "" } }, usesOnChanges: true, ngImport: i0, template: "", isInline: true, styles: [":host{display:block}"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: DesignerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "seatschart-designer", standalone: true, template: "", changeDetection: ChangeDetectionStrategy.OnPush, host: { "data-seatschart-designer": "" }, inputs: [...INPUTS], outputs: [...OUTPUTS], styles: [":host{display:block}"] }]
+        }], ctorParameters: () => [] });
+for (const name of DESIGNER_COMMANDS) {
+    Object.defineProperty(DesignerComponent.prototype, name, {
+        configurable: true,
+        writable: true,
+        value(...args) {
+            return runCommand(bindings.get(this)?.current ?? null, name, DESIGNER_KIND.label, args);
+        },
+    });
+}
+/** `<seatschart-designer>` input names. */
+export const DESIGNER_INPUTS = INPUTS;
+/** `<seatschart-designer>` output names (`onError` → `designerError`). */
+export const DESIGNER_OUTPUTS = OUTPUTS;

package/dist/event-manager.component.d.ts

@@ -0,0 +1,61 @@
+import { type AfterViewInit, type EventEmitter, type OnChanges, type OnDestroy } from "@angular/core";
+import type { EventManagerCallbacks, EventManagerErrorInfo, SeatsChartEventManager, SeatsChartEventManagerConfig } from "@seatschart/embed";
+import { type EventManagerCallbackKey, type EventManagerCommands, type EventManagerConfigKey } from "./host-core.js";
+import { type CallbackOutputs } from "./outputs.js";
+import * as i0 from "@angular/core";
+/** `<seatschart-event-manager>` inputs: the `SeatsChartEventManager` config (seats.io `EventManager` names). */
+export type EventManagerInputs = {
+    [K in EventManagerConfigKey]?: SeatsChartEventManagerConfig[K];
+};
+/**
+ * Every manager callback as an output (`onSelectionChanged` → `(selectionChanged)`). `onError` is `(managerError)`:
+ * an output named like a DOM event would also catch native `error` events.
+ */
+export type EventManagerOutputs = Omit<CallbackOutputs<EventManagerCallbacks, EventManagerCallbackKey>, "error"> & {
+    readonly managerError: EventEmitter<EventManagerErrorInfo>;
+};
+declare const INPUTS: readonly ["isObjectSelectable", "unavailableObjectsSelectable", "selectableObjects", "selectedObjects", "maxSelectedObjects", "order", "filters", "webBase", "event", "eventId", "token", "mode", "language", "colorScheme", "parentOrigin", "height", "title", "className", "timeoutMs"];
+declare const OUTPUTS: readonly ["eventManagerRendered", "chartRendered", "chartRenderingFailed", "objectSelected", "objectDeselected", "selectionChanged", "selectionInvalid", "orderChanged", "modeChanged", "submitSucceeded", "submitFailed", "managerError"];
+type Assert<T extends true> = T;
+type Same<A, B> = [Exclude<A, B> | Exclude<B, A>] extends [never] ? true : false;
+/** Compile-time guard: the literal lists name every manager option and callback. */
+export type EventManagerMetadataCovered = [
+    Assert<Same<(typeof INPUTS)[number], keyof EventManagerInputs>>,
+    Assert<Same<(typeof OUTPUTS)[number], keyof EventManagerOutputs>>
+];
+/**
+ * `<seatschart-event-manager>`: the embedded SeatsChart Event Manager (back office). Selectability rules,
+ * `maxSelectedObjects`, `selectedObjects`, `order`, `filters`, `language` and `colorScheme` are applied live with
+ * `changeConfig`; other changes re-render the iframe. Every `SeatsChartEventManager` command is a method. `token` is a
+ * short-lived manager embed token from your backend — never a secret key.
+ */
+export declare class EventManagerComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly host;
+    private readonly zone;
+    private readonly browser;
+    private readonly forwarders;
+    constructor();
+    /**
+     * The underlying `SeatsChartEventManager` (null before the view is ready, on the server and after destroy):
+     * `manager?.selectedObjects` and `manager?.mode` give the live selection and mode (the component's
+     * `selectedObjects` / `mode` are the inputs).
+     */
+    get manager(): SeatsChartEventManager | null;
+    getIframe(): HTMLIFrameElement | null;
+    /** Re-create the iframe with the current inputs (the selection is cleared). */
+    rerender(): void;
+    ngOnChanges(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private config;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventManagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EventManagerComponent, "seatschart-event-manager", never, { "isObjectSelectable": { "alias": "isObjectSelectable"; "required": false; }; "unavailableObjectsSelectable": { "alias": "unavailableObjectsSelectable"; "required": false; }; "selectableObjects": { "alias": "selectableObjects"; "required": false; }; "selectedObjects": { "alias": "selectedObjects"; "required": false; }; "maxSelectedObjects": { "alias": "maxSelectedObjects"; "required": false; }; "order": { "alias": "order"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "webBase": { "alias": "webBase"; "required": false; }; "event": { "alias": "event"; "required": false; }; "eventId": { "alias": "eventId"; "required": false; }; "token": { "alias": "token"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "language": { "alias": "language"; "required": false; }; "colorScheme": { "alias": "colorScheme"; "required": false; }; "parentOrigin": { "alias": "parentOrigin"; "required": false; }; "height": { "alias": "height"; "required": false; }; "title": { "alias": "title"; "required": false; }; "className": { "alias": "className"; "required": false; }; "timeoutMs": { "alias": "timeoutMs"; "required": false; }; }, { "eventManagerRendered": "eventManagerRendered"; "chartRendered": "chartRendered"; "chartRenderingFailed": "chartRenderingFailed"; "objectSelected": "objectSelected"; "objectDeselected": "objectDeselected"; "selectionChanged": "selectionChanged"; "selectionInvalid": "selectionInvalid"; "orderChanged": "orderChanged"; "modeChanged": "modeChanged"; "submitSucceeded": "submitSucceeded"; "submitFailed": "submitFailed"; "managerError": "managerError"; }, never, never, true, never>;
+}
+export interface EventManagerComponent extends EventManagerInputs, EventManagerOutputs, EventManagerCommands {
+}
+/** `<seatschart-event-manager>` input names. */
+export declare const EVENT_MANAGER_INPUTS: readonly string[];
+/** `<seatschart-event-manager>` output names (`onError` → `managerError`). */
+export declare const EVENT_MANAGER_OUTPUTS: readonly string[];
+export {};
+//# sourceMappingURL=event-manager.component.d.ts.map

package/dist/event-manager.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-manager.component.d.ts","sourceRoot":"","sources":["../src/event-manager.component.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,4BAA4B,EAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAML,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAE3B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAA+C,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;;AAEjG,gHAAgH;AAChH,MAAM,MAAM,kBAAkB,GAAG;KAAG,CAAC,IAAI,qBAAqB,CAAC,CAAC,EAAE,4BAA4B,CAAC,CAAC,CAAC;CAAE,CAAC;AAEpG;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,eAAe,CAAC,qBAAqB,EAAE,uBAAuB,CAAC,EAAE,OAAO,CAAC,GAAG;IACjH,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,qBAAqB,CAAC,CAAC;CAC5D,CAAC;AAEF,QAAA,MAAM,MAAM,2RAIF,CAAC;AACX,QAAA,MAAM,OAAO,4OAIH,CAAC;AAGX,KAAK,MAAM,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAChC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AACjF,oFAAoF;AACpF,MAAM,MAAM,2BAA2B,GAAG;IACxC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,kBAAkB,CAAC,CAAC;IAC/D,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,mBAAmB,CAAC,CAAC;CAClE,CAAC;AAIF;;;;;GAKG;AACH,qBAUa,qBAAsB,YAAW,aAAa,EAAE,SAAS,EAAE,SAAS;IAC/E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+C;IACpE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAc;;IAQzC;;;;OAIG;IACH,IAAI,OAAO,IAAI,sBAAsB,GAAG,IAAI,CAE3C;IAED,SAAS,IAAI,iBAAiB,GAAG,IAAI;IAIrC,+EAA+E;IAC/E,QAAQ,IAAI,IAAI;IAIhB,WAAW,IAAI,IAAI;IAKnB,eAAe,IAAI,IAAI;IAMvB,WAAW,IAAI,IAAI;IAInB,OAAO,CAAC,MAAM;yCA7CH,qBAAqB;2CAArB,qBAAqB;CAgDjC;AAED,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB;CAAG;AAY/G,gDAAgD;AAChD,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAAW,CAAC;AAC9D,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAAY,CAAC"}

package/dist/event-manager.component.js

@@ -0,0 +1,83 @@
+import { isPlatformBrowser } from "@angular/common";
+import { ChangeDetectionStrategy, Component, ElementRef, NgZone, PLATFORM_ID, inject, } from "@angular/core";
+import { EVENT_MANAGER_CALLBACKS, EVENT_MANAGER_COMMANDS, EVENT_MANAGER_KIND, EmbedBinding, runCommand, } from "./host-core.js";
+import { createOutputs, outputForwarders, pickInputs } from "./outputs.js";
+import * as i0 from "@angular/core";
+const INPUTS = [
+    "isObjectSelectable", "unavailableObjectsSelectable", "selectableObjects", "selectedObjects", "maxSelectedObjects",
+    "order", "filters", "webBase", "event", "eventId", "token", "mode", "language", "colorScheme", "parentOrigin",
+    "height", "title", "className", "timeoutMs",
+];
+const OUTPUTS = [
+    "eventManagerRendered", "chartRendered", "chartRenderingFailed", "objectSelected", "objectDeselected",
+    "selectionChanged", "selectionInvalid", "orderChanged", "modeChanged", "submitSucceeded", "submitFailed",
+    "managerError",
+];
+const RENAMES = { onError: "managerError" };
+const bindings = new WeakMap();
+/**
+ * `<seatschart-event-manager>`: the embedded SeatsChart Event Manager (back office). Selectability rules,
+ * `maxSelectedObjects`, `selectedObjects`, `order`, `filters`, `language` and `colorScheme` are applied live with
+ * `changeConfig`; other changes re-render the iframe. Every `SeatsChartEventManager` command is a method. `token` is a
+ * short-lived manager embed token from your backend — never a secret key.
+ */
+export class EventManagerComponent {
+    constructor() {
+        this.host = inject(ElementRef);
+        this.zone = inject(NgZone);
+        this.browser = isPlatformBrowser(inject(PLATFORM_ID));
+        createOutputs(this, OUTPUTS);
+        bindings.set(this, new EmbedBinding(EVENT_MANAGER_KIND));
+        this.forwarders = outputForwarders(this, EVENT_MANAGER_CALLBACKS, this.zone, RENAMES);
+    }
+    /**
+     * The underlying `SeatsChartEventManager` (null before the view is ready, on the server and after destroy):
+     * `manager?.selectedObjects` and `manager?.mode` give the live selection and mode (the component's
+     * `selectedObjects` / `mode` are the inputs).
+     */
+    get manager() {
+        return bindings.get(this)?.current ?? null;
+    }
+    getIframe() {
+        return this.manager?.getIframe() ?? null;
+    }
+    /** Re-create the iframe with the current inputs (the selection is cleared). */
+    rerender() {
+        this.zone.runOutsideAngular(() => bindings.get(this)?.rerender());
+    }
+    ngOnChanges() {
+        const config = this.config();
+        this.zone.runOutsideAngular(() => bindings.get(this)?.update(config));
+    }
+    ngAfterViewInit() {
+        if (!this.browser)
+            return;
+        const config = this.config();
+        this.zone.runOutsideAngular(() => bindings.get(this)?.mount(this.host.nativeElement, config));
+    }
+    ngOnDestroy() {
+        bindings.get(this)?.destroy();
+    }
+    config() {
+        return { ...pickInputs(this, INPUTS), ...this.forwarders };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: EventManagerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.25", type: EventManagerComponent, isStandalone: true, selector: "seatschart-event-manager", inputs: { isObjectSelectable: "isObjectSelectable", unavailableObjectsSelectable: "unavailableObjectsSelectable", selectableObjects: "selectableObjects", selectedObjects: "selectedObjects", maxSelectedObjects: "maxSelectedObjects", order: "order", filters: "filters", webBase: "webBase", event: "event", eventId: "eventId", token: "token", mode: "mode", language: "language", colorScheme: "colorScheme", parentOrigin: "parentOrigin", height: "height", title: "title", className: "className", timeoutMs: "timeoutMs" }, outputs: { eventManagerRendered: "eventManagerRendered", chartRendered: "chartRendered", chartRenderingFailed: "chartRenderingFailed", objectSelected: "objectSelected", objectDeselected: "objectDeselected", selectionChanged: "selectionChanged", selectionInvalid: "selectionInvalid", orderChanged: "orderChanged", modeChanged: "modeChanged", submitSucceeded: "submitSucceeded", submitFailed: "submitFailed", managerError: "managerError" }, host: { attributes: { "data-seatschart-event-manager": "" } }, usesOnChanges: true, ngImport: i0, template: "", isInline: true, styles: [":host{display:block}"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.25", ngImport: i0, type: EventManagerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "seatschart-event-manager", standalone: true, template: "", changeDetection: ChangeDetectionStrategy.OnPush, host: { "data-seatschart-event-manager": "" }, inputs: [...INPUTS], outputs: [...OUTPUTS], styles: [":host{display:block}"] }]
+        }], ctorParameters: () => [] });
+for (const name of EVENT_MANAGER_COMMANDS) {
+    Object.defineProperty(EventManagerComponent.prototype, name, {
+        configurable: true,
+        writable: true,
+        value(...args) {
+            return runCommand(bindings.get(this)?.current ?? null, name, EVENT_MANAGER_KIND.label, args);
+        },
+    });
+}
+/** `<seatschart-event-manager>` input names. */
+export const EVENT_MANAGER_INPUTS = INPUTS;
+/** `<seatschart-event-manager>` output names (`onError` → `managerError`). */
+export const EVENT_MANAGER_OUTPUTS = OUTPUTS;

package/dist/host-core.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Framework-agnostic glue between a component and one `@seatschart/embed` host instance (`SeatsChart`,
+ * `SeatsChartEventManager` or `SeatsChartDesigner`). This file is identical in `@seatschart/vue` and
+ * `@seatschart/angular` (a unit test keeps the two copies in step): the wrappers only map framework props, events
+ * and lifecycle onto it, every embed behaviour (iframe, origin checks, commands, sessions) stays in the embed.
+ *
+ * Prop updates are compared by value with what the instance last received, then applied the cheapest correct way:
+ * iframe attributes in place, live keys through `changeConfig` (no reload), other keys through `rerender(config)`
+ * (the hold session / the created chart is kept), mount-only keys by re-creating the instance.
+ */
+import { DESIGNER_CALLBACKS, EVENT_MANAGER_CALLBACKS, SeatsChart, SeatsChartDesigner, SeatsChartEventManager, type SeatsChartConfig, type SeatsChartDesignerConfig, type SeatsChartEventManagerConfig } from "@seatschart/embed";
+/** Every buyer chart option a component accepts as a prop / input (the host config keys first). */
+export declare const CHART_CONFIG_KEYS: readonly ["objectColor", "objectLabel", "tooltip", "priceFormatter", "numberOfPlacesToSelect", "maxSelectedObjects", "showSectionContents", "showMinimap", "showSurroundings", "sessionMode", "selectionValidators", "accessibilityFilter", "mode", "prompts", "objectWithoutPricingSelectable", "fitTo", "loading", "messages", "selectedObjects", "gestureHandling", "selectionModes", "showSeatLabels", "minimumSelectedPlaces", "sectionColor", "objectIcon", "isObjectVisible", "hideSectionsNotForSale", "selectableObjects", "objectWithoutCategorySelectable", "showSectionPricingOverlay", "showObjectPopover", "showFilterControls", "showLegend", "showZoomOutButton", "showFullScreenButton", "fullScreenTarget", "canGoBack", "resaleListings", "partySize", "style", "objectPopover", "legend", "filterControls", "activeFloor", "lockActiveFloor", "showFloorElevator", "settings3d", "webBase", "event", "events", "publicKey", "workspaceKey", "token", "parentOrigin", "channel", "channelKey", "channelKeys", "session", "season", "language", "multiSelectEnabled", "holdToken", "availableCategories", "unavailableCategories", "currency", "theme", "statusPalette", "transparent", "backgroundColor", "pricing", "defaultRenderer", "height", "title", "className", "allowFullscreen", "timeoutMs", "holdTokenInputName", "selectedObjectsInputName", "form"];
+export type ChartConfigKey = (typeof CHART_CONFIG_KEYS)[number];
+/** Chart callbacks (seats.io names) forwarded as component events. */
+export declare const CHART_CALLBACKS: readonly ["onObjectSelected", "onObjectDeselected", "onSessionHold", "onHoldSucceeded", "onHoldCallsInProgress", "onHoldCallsComplete", "onHoldConfirmed", "onReleaseHoldSucceeded", "onReleaseHoldFailed", "onSelectedObjectUnavailable", "onChartRerenderingStarted", "onPromptRequest", "onHoldTokenExpired", "onChartRendered", "onChartRenderingFailed", "onObjectClicked", "onObjectHovered", "onObjectUnhovered", "onHoldFailed", "onSelectionInvalid", "onSelectionValid", "onObjectStatusChanged", "onBestAvailableSelected", "onBestAvailableFailed", "onFilteredCategoriesChanged", "onAccessibilityFilterChanged", "onFiltersChanged", "onSessionInitialized", "onFloorChanged", "onFullScreenOpened", "onFullScreenClosed", "onFullScreenRequest", "onObjectMouseOver", "onObjectMouseOut", "onBestAvailableSelectionFailed", "onSelectedObjectBooked", "onHoldCreated"];
+export type ChartCallbackKey = (typeof CHART_CALLBACKS)[number];
+/** Host-drawn prompts: registering one switches the matching viewer prompt to the host. */
+export declare const PROMPT_CALLBACKS: readonly ["onPlacesPrompt", "onTicketTypePrompt", "onPlacesWithTicketTypesPrompt"];
+export type PromptCallbackKey = (typeof PROMPT_CALLBACKS)[number];
+export declare const EVENT_MANAGER_KEYS: readonly ["isObjectSelectable", "unavailableObjectsSelectable", "selectableObjects", "selectedObjects", "maxSelectedObjects", "order", "filters", "webBase", "event", "eventId", "token", "mode", "language", "colorScheme", "parentOrigin", "height", "title", "className", "timeoutMs"];
+export type EventManagerConfigKey = (typeof EVENT_MANAGER_KEYS)[number];
+export { EVENT_MANAGER_CALLBACKS };
+export type EventManagerCallbackKey = (typeof EVENT_MANAGER_CALLBACKS)[number];
+export declare const DESIGNER_KEYS: readonly ["webBase", "chartId", "chartKey", "token", "mode", "safeModeOptions", "features", "language", "colorScheme", "canvasColorScheme", "openDraftDrawing", "openLatestDrawing", "parentOrigin", "height", "title", "className", "timeoutMs"];
+export type DesignerConfigKey = (typeof DESIGNER_KEYS)[number];
+export { DESIGNER_CALLBACKS };
+export type DesignerCallbackKey = (typeof DESIGNER_CALLBACKS)[number];
+type Assert<T extends true> = T;
+type Covers<All, Listed> = [Exclude<All, Listed>] extends [never] ? true : false;
+/** Compile-time guard: a new embed option or callback must be mapped by the wrappers. */
+export type ConfigKeysCovered = [
+    Assert<Covers<keyof SeatsChartConfig, ChartConfigKey | ChartCallbackKey | PromptCallbackKey | "divId" | "container">>,
+    Assert<Covers<keyof SeatsChartEventManagerConfig, EventManagerConfigKey | EventManagerCallbackKey | "divId" | "container">>,
+    Assert<Covers<keyof SeatsChartDesignerConfig, DesignerConfigKey | DesignerCallbackKey | "divId" | "container">>
+];
+/** `"onObjectSelected"` → `"objectSelected"` (Vue event / Angular output name). */
+export type EventNameOf<K> = K extends `on${infer N}` ? Uncapitalize<N> : never;
+/** `onObjectSelected` → `objectSelected`. */
+export declare function eventName<K extends string>(callback: K): EventNameOf<K>;
+type PromiseMethods<T> = {
+    [K in keyof T]-?: T[K] extends (...args: never[]) => Promise<unknown> ? K : never;
+}[keyof T];
+/** Every promise command of `SeatsChart` (each waits for the chart to render; rejects with `ChartCommandError`). */
+export declare const CHART_COMMANDS: readonly ["whenReady", "request", "selectObjects", "deselectObjects", "clearSelection", "listSelectedObjects", "selectBestAvailable", "findObject", "listCategories", "setFilteredCategories", "clearFilteredCategories", "setFilters", "clearFilters", "highlightObjects", "clearHighlights", "zoomToObjects", "zoomToSelectedObjects", "zoomToSection", "zoomToFilteredCategories", "resetView", "goToFloor", "listFloors", "goToAllFloorsView", "getReportBySelectability", "getReportBySelectabilityGroupedBy", "getHoldToken", "startNewSession", "releaseHoldToken", "isObjectInChannel", "showViewFromSeat", "trySelectObjects", "doSelectObjects", "selectCategories", "deselectCategories", "listZones", "setSpotlight", "setSpotlightObjects", "setSpotlightOnSelection", "clearSpotlight", "clearSpotlightObjects", "pulse", "unpulse", "resolvePrompt", "exportImage", "setPricing", "changeConfig"];
+export type ChartCommands = Pick<SeatsChart, (typeof CHART_COMMANDS)[number]>;
+/** Every promise command of `SeatsChartEventManager` (seats.io `EventManager` methods). */
+export declare const EVENT_MANAGER_COMMANDS: readonly ["whenReady", "request", "listSelectedObjects", "selectObjects", "doSelectObjects", "trySelectObjects", "deselectObjects", "clearSelection", "setHighlightedObjects", "clearHighlightedObjects", "listOrderChanges", "zoomToObjects", "zoomToSelectedObjects", "changeConfig"];
+export type EventManagerCommands = Pick<SeatsChartEventManager, (typeof EVENT_MANAGER_COMMANDS)[number]>;
+/** Every promise command of `SeatsChartDesigner`. */
+export declare const DESIGNER_COMMANDS: readonly ["whenReady", "request", "save", "publish", "getState", "changeConfig"];
+export type DesignerCommands = Pick<SeatsChartDesigner, (typeof DESIGNER_COMMANDS)[number]>;
+/** Compile-time guard: a new embed command must be exposed by the wrappers. */
+export type CommandsCovered = [
+    Assert<Covers<PromiseMethods<SeatsChart>, (typeof CHART_COMMANDS)[number]>>,
+    Assert<Covers<PromiseMethods<SeatsChartEventManager>, (typeof EVENT_MANAGER_COMMANDS)[number]>>,
+    Assert<Covers<PromiseMethods<SeatsChartDesigner>, (typeof DESIGNER_COMMANDS)[number]>>
+];
+/**
+ * Methods that forward to the current instance (re-created instances included). Before mount and after unmount
+ * they reject with `ChartCommandError` ("… is not mounted.") instead of throwing.
+ */
+export declare function delegateCommands<I extends object, K extends keyof I & string>(current: () => I | null, names: readonly K[], label: string): Pick<I, K>;
+/** Run one promise command on the instance (rejects with `ChartCommandError` without one). */
+export declare function runCommand(instance: object | null, name: string, label: string, args: readonly unknown[]): Promise<unknown>;
+/**
+ * Order-independent fingerprint of a prop value: plain objects and arrays by value (reactive proxies included),
+ * functions as "a function", other objects (a form element) by identity. `undefined` = not set.
+ */
+export declare function valueKey(value: unknown): string | undefined;
+/**
+ * Deep copy of plain objects and arrays (reactive proxies become plain data the embed can post to the iframe);
+ * functions and other objects are kept as they are.
+ */
+export declare function toPlain<T>(value: T): T;
+/** What every embed host instance offers the binding. */
+export type EmbedInstance = {
+    render(): unknown;
+    destroy(): void;
+    getIframe(): HTMLIFrameElement | null;
+};
+export type EmbedConfig = Record<string, unknown>;
+export type EmbedKind<I extends EmbedInstance> = {
+    /** "Seat chart", "Event Manager", "Designer" (error messages). */
+    label: string;
+    create: (config: EmbedConfig & {
+        container: HTMLElement;
+    }) => I;
+    rerender: (instance: I, config: EmbedConfig) => void;
+    changeConfig: (instance: I, patch: EmbedConfig, config: EmbedConfig) => Promise<unknown>;
+    /** Keys applied live through `changeConfig`. */
+    liveKeys: ReadonlySet<string>;
+    /** Keys read when the instance is created (a change re-creates it). */
+    mountKeys: ReadonlySet<string>;
+    defaultHeight: number;
+    defaultTitle: string;
+};
+export type BindingAction = "none" | "frame" | "changeConfig" | "rerender" | "remount";
+/** One mounted embed instance driven by component props. */
+export declare class EmbedBinding<I extends EmbedInstance> {
+    private readonly kind;
+    private instance;
+    private container;
+    private config;
+    private applied;
+    constructor(kind: EmbedKind<I>);
+    /** The live embed instance (null before mount / after unmount). */
+    get current(): I | null;
+    get label(): string;
+    /** Create the instance in `container` and render it (browser only). */
+    mount(container: HTMLElement, config: EmbedConfig): void;
+    /** Apply new props; returns what was done (tests and diagnostics). */
+    update(next: EmbedConfig): BindingAction;
+    /** Re-create the iframe with the current props (seats.io `rerender()`). */
+    rerender(): void;
+    /** Remove the iframe and every listener. */
+    destroy(): void;
+    private remember;
+    private remount;
+    private applyFrame;
+}
+export declare const CHART_KIND: EmbedKind<SeatsChart>;
+export declare const EVENT_MANAGER_KIND: EmbedKind<SeatsChartEventManager>;
+export declare const DESIGNER_KIND: EmbedKind<SeatsChartDesigner>;
+//# sourceMappingURL=host-core.d.ts.map