@kerusiweb/angular 2.0.0

package/types/kerusiweb-angular.d.ts

@@ -0,0 +1,390 @@
+import * as _kerusiweb_core from '@kerusiweb/core';
+import { KerusiMap, KerusiState, KerusiSession, SeatAriaStrings, KerusiSeatmapColors, RenderSeat, DisallowedReason, KerusiViolation, RenderMap, SectionLayout, RenderSection, PlacedSeat, SeatOccupantVariant, PlacedElement, RenderLegendEntry, SequenceReader, HeldSeat, KerusiStateDelta, DeltaApplication } from '@kerusiweb/core';
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+/** How a document with validation errors is handled. */
+type ValidationMode = 
+/** Report through `validationIssues` and render anyway. The default. */
+'collect'
+/** Throw a `KerusiValidationError`, as `validateKerusiMap` does. */
+ | 'throw'
+/** Skip validation entirely, for a document validated upstream. */
+ | 'off';
+/** Per-section rendering overrides, keyed by `Section.id`. */
+interface SectionRenderOptions {
+    hidden?: boolean;
+    /** Overrides `Section.aspectRatio`. */
+    aspectRatio?: string;
+    /** Overrides the seat size for this section only. */
+    seatSize?: number;
+    /** Overrides the localized `Section.label`. */
+    label?: string;
+}
+/** What a seat event carries. Everything the document knows, already resolved. */
+interface SeatInteraction {
+    seat: RenderSeat;
+    /** The selection after this event. */
+    selection: readonly string[];
+    /** Seats whose membership changed, including companions (§4.6). */
+    changed: readonly string[];
+}
+interface SeatDisallowed {
+    seat: RenderSeat;
+    reason: DisallowedReason;
+}
+/**
+ * Renders a Kerusi seat map.
+ *
+ * Takes a `KerusiMap` and its `KerusiState` directly — no adapter, no
+ * intermediate row model. Each `Section` becomes its own `<svg>` with its own
+ * layout mode and proportions, seats take their color from the map's legend,
+ * every seat is keyboard-reachable and announced with its type, price, status
+ * and §4.3.4 accessibility properties, and selection is an immutable set of
+ * seat ids the caller can two-way bind.
+ *
+ * ```html
+ * <kerusi-seatmap [map]="map" [state]="state" [(selection)]="picked" />
+ * ```
+ */
+declare class KerusiSeatmapComponent {
+    private readonly host;
+    readonly map: _angular_core.InputSignal<KerusiMap>;
+    readonly state: _angular_core.InputSignal<KerusiState | undefined>;
+    /** The optional map↔event join (§5.3). Validated against the map and state. */
+    readonly session: _angular_core.InputSignal<KerusiSession | undefined>;
+    /** Selected seat ids. Two-way: `[(selection)]`, or read-only with `[selection]`. */
+    readonly selection: _angular_core.ModelSignal<readonly string[]>;
+    /** Overrides `KerusiMap.locale` (BCP-47). */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Right-to-left rendering. `auto` derives it from the resolved locale. */
+    readonly rtl: _angular_core.InputSignal<boolean | "auto">;
+    /** Overrides the built-in English announcement strings. */
+    readonly ariaStrings: _angular_core.InputSignal<SeatAriaStrings>;
+    readonly colors: _angular_core.InputSignal<KerusiSeatmapColors>;
+    /** Let an available seat take its `SeatType.color` (§4.7). */
+    readonly typeColors: _angular_core.InputSignal<boolean>;
+    /** Grid cell edge, in viewBox units. */
+    readonly seatSize: _angular_core.InputSignal<number>;
+    /** Gap between grid cells, in viewBox units. */
+    readonly seatGap: _angular_core.InputSignal<number>;
+    /** Freeform viewBox width; height follows the section's aspect ratio. */
+    readonly freeformBasis: _angular_core.InputSignal<number>;
+    /**
+     * CSS pixels per viewBox unit. Caps each section at its natural size so a
+     * narrow section and a wide one in the same map draw seats the same size.
+     */
+    readonly unitScale: _angular_core.InputSignal<number>;
+    readonly showSectionLabels: _angular_core.InputSignal<boolean>;
+    readonly showLegend: _angular_core.InputSignal<boolean>;
+    readonly showLegendPrices: _angular_core.InputSignal<boolean>;
+    /** Render only these sections, in this order. Default: all, by `Section.index`. */
+    readonly sectionIds: _angular_core.InputSignal<readonly string[] | undefined>;
+    readonly sectionOverrides: _angular_core.InputSignal<Readonly<Record<string, SectionRenderOptions>>>;
+    /** Statuses in which a seat may be picked. Default: `['available']`. */
+    readonly selectableStatuses: _angular_core.InputSignal<readonly ("held" | "booked" | "available" | "blocked")[]>;
+    /** `auto` selects a seat's companion closure together (§4.6). */
+    readonly companionMode: _angular_core.InputSignal<"auto" | "independent">;
+    readonly maxSelection: _angular_core.InputSignal<number | undefined>;
+    /** A final say on selectability, applied after the status test. */
+    readonly seatSelectable: _angular_core.InputSignal<((seat: RenderSeat) => boolean) | undefined>;
+    /** When false the map renders read-only: no pointer or keyboard interaction. */
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    /**
+     * Revert a lapsed `holdExpires` to available on a ticker (§5.1). Off by
+     * default — a renderer should stay passive unless asked.
+     */
+    readonly expireHolds: _angular_core.InputSignal<boolean>;
+    readonly expiryIntervalMs: _angular_core.InputSignal<number>;
+    readonly validate: _angular_core.InputSignal<ValidationMode>;
+    readonly seatSelect: _angular_core.OutputEmitterRef<SeatInteraction>;
+    readonly seatDeselect: _angular_core.OutputEmitterRef<SeatInteraction>;
+    readonly seatDisallowed: _angular_core.OutputEmitterRef<SeatDisallowed>;
+    readonly seatFocus: _angular_core.OutputEmitterRef<RenderSeat>;
+    /** Emitted whenever the documents change, in `collect` mode. */
+    readonly validationIssues: _angular_core.OutputEmitterRef<readonly KerusiViolation[]>;
+    /**
+     * The seat holding each section's tab stop, keyed by section id.
+     *
+     * Per section, not per map: arrow keys never cross a section boundary, so a
+     * single map-wide tab stop would leave every section after the first
+     * unreachable by keyboard. Tab moves between sections, arrows move within.
+     */
+    private readonly focusedSeatIds;
+    private readonly announcement;
+    /** Bumped by the hold ticker to force the state to be re-derived. */
+    private readonly expiryTick;
+    constructor();
+    protected readonly issues: _angular_core.Signal<readonly KerusiViolation[]>;
+    /** The state actually rendered — with lapsed holds reverted when asked. */
+    private readonly effectiveState;
+    protected readonly renderMap: _angular_core.Signal<RenderMap>;
+    protected readonly resolvedLocale: _angular_core.Signal<string>;
+    protected readonly isRtl: _angular_core.Signal<boolean>;
+    protected readonly resolvedColors: _angular_core.Signal<Required<KerusiSeatmapColors>>;
+    protected readonly selectionSet: _angular_core.Signal<Set<string>>;
+    /** Placed geometry per section, keyed by section id. */
+    protected readonly layouts: _angular_core.Signal<ReadonlyMap<string, SectionLayout>>;
+    /** Navigation graphs per section — arrows move within, Tab moves between. */
+    private readonly graphs;
+    protected readonly ariaLabels: _angular_core.Signal<ReadonlyMap<string, string>>;
+    protected readonly mapLabel: _angular_core.Signal<string>;
+    /** Live-region text: the running selection, or the last disallowed reason. */
+    protected readonly liveMessage: _angular_core.Signal<string>;
+    /** The selection's seats and total, for callers that want it off the template. */
+    readonly summary: _angular_core.Signal<_kerusiweb_core.SelectionSummary>;
+    protected layoutFor(section: RenderSection): SectionLayout;
+    protected labelFor(section: RenderSection): string | undefined;
+    protected labelId(section: RenderSection): string;
+    /** The seat holding this section's tab stop. */
+    protected focusedSeatIn(section: RenderSection): string | null;
+    protected onSeatActivate(seatId: string): void;
+    protected onSeatFocused(seatId: string): void;
+    /**
+     * Arrow keys walk the navigation graph, which orders seats by `col` in grid
+     * and mixed sections — §4.3.1's logical adjacency — so the aisle that is a
+     * skipped column is stepped across rather than into.
+     */
+    protected onKeydown(section: RenderSection, event: KeyboardEvent): void;
+    private setFocusedSeat;
+    /**
+     * Moves the roving tab stop, then the DOM focus that follows it.
+     *
+     * Seat ids come from the document, so they cannot be interpolated into a
+     * selector unescaped — and `CSS.escape` is absent in jsdom and under SSR.
+     * Scanning the rendered nodes avoids both problems.
+     */
+    private moveFocusTo;
+    private announceSelection;
+    private announce;
+    private visibleSectionIds;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KerusiSeatmapComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KerusiSeatmapComponent, "kerusi-seatmap", never, { "map": { "alias": "map"; "required": true; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "session": { "alias": "session"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "rtl": { "alias": "rtl"; "required": false; "isSignal": true; }; "ariaStrings": { "alias": "ariaStrings"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "typeColors": { "alias": "typeColors"; "required": false; "isSignal": true; }; "seatSize": { "alias": "seatSize"; "required": false; "isSignal": true; }; "seatGap": { "alias": "seatGap"; "required": false; "isSignal": true; }; "freeformBasis": { "alias": "freeformBasis"; "required": false; "isSignal": true; }; "unitScale": { "alias": "unitScale"; "required": false; "isSignal": true; }; "showSectionLabels": { "alias": "showSectionLabels"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; "showLegendPrices": { "alias": "showLegendPrices"; "required": false; "isSignal": true; }; "sectionIds": { "alias": "sectionIds"; "required": false; "isSignal": true; }; "sectionOverrides": { "alias": "sectionOverrides"; "required": false; "isSignal": true; }; "selectableStatuses": { "alias": "selectableStatuses"; "required": false; "isSignal": true; }; "companionMode": { "alias": "companionMode"; "required": false; "isSignal": true; }; "maxSelection": { "alias": "maxSelection"; "required": false; "isSignal": true; }; "seatSelectable": { "alias": "seatSelectable"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "expireHolds": { "alias": "expireHolds"; "required": false; "isSignal": true; }; "expiryIntervalMs": { "alias": "expiryIntervalMs"; "required": false; "isSignal": true; }; "validate": { "alias": "validate"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "seatSelect": "seatSelect"; "seatDeselect": "seatDeselect"; "seatDisallowed": "seatDisallowed"; "seatFocus": "seatFocus"; "validationIssues": "validationIssues"; }, never, never, true, never>;
+}
+
+/**
+ * Draws one Kerusi `Section` as a single `<svg>`.
+ *
+ * One SVG per section — rather than section groups inside a shared canvas — is
+ * what makes per-section `aspectRatio` and mixed grid/freeform modes work: each
+ * gets its own `viewBox` and its own intrinsic proportions, and CSS is free to
+ * stack, wrap or column them. It also puts the section heading in real DOM,
+ * where a screen reader can use it as a landmark.
+ *
+ * This component holds no state. It takes a placed layout and emits intent.
+ */
+declare class KerusiSectionComponent {
+    readonly section: _angular_core.InputSignal<RenderSection>;
+    readonly layout: _angular_core.InputSignal<SectionLayout>;
+    /** Currently selected seat ids. */
+    readonly selection: _angular_core.InputSignal<ReadonlySet<string>>;
+    /** The seat holding the section's single tab stop, if any. */
+    readonly focusedSeatId: _angular_core.InputSignal<string | null>;
+    /** Per-seat accessible names, keyed by seat id. */
+    readonly ariaLabels: _angular_core.InputSignal<ReadonlyMap<string, string>>;
+    readonly colors: _angular_core.InputSignal<Required<KerusiSeatmapColors>>;
+    /** Whether an available seat may take its `SeatType.color` (§4.7). */
+    readonly typeColors: _angular_core.InputSignal<boolean>;
+    /** When false, seats render but do not respond to pointer or keyboard. */
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    /**
+     * CSS pixels per viewBox unit, at the section's natural size.
+     *
+     * Without a cap every section stretches to the full container width, so in a
+     * four-tier theatre the narrow box row would draw seats several times the
+     * size of the orchestra's. Capping each section at its own intrinsic width
+     * keeps a seat the same size everywhere; a section too wide to fit still
+     * scales down to the container.
+     */
+    readonly unitScale: _angular_core.InputSignal<number>;
+    readonly seatActivate: _angular_core.OutputEmitterRef<string>;
+    readonly seatFocused: _angular_core.OutputEmitterRef<string>;
+    readonly seatKeydown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    protected readonly viewBox: _angular_core.Signal<string>;
+    /** The section's natural width in CSS pixels; it never draws wider. */
+    protected readonly naturalWidth: _angular_core.Signal<number>;
+    protected isSelected(placed: PlacedSeat): boolean;
+    protected fill(placed: PlacedSeat): string;
+    protected textFill(placed: PlacedSeat): string;
+    protected backdrop(): string;
+    /** The seat's outline: square-ish front, tapered back — shape carries facing. */
+    protected bodyPath(placed: PlacedSeat): string;
+    /** `null` for an available or blocked seat — nothing to mark. */
+    protected occupantVariant(placed: PlacedSeat): SeatOccupantVariant | null;
+    /**
+     * The box a seat's decorative marks are drawn to: the seat's own, or — when
+     * it is selected — the core plate's, which is inset by the frame width.
+     *
+     * Everything over a selected seat sits on the core, so it all has to be
+     * measured from the core. Drawing to the seat's box instead leaves the
+     * occupant's hips crossing the frame, where a figure tinted `selectedBg`
+     * lands on a frame filled `selectedBg` and reads as a hard nub. Since the
+     * core is an exact scaled copy of the body (see {@link seatSelectedFrame}),
+     * routing through here reproduces every clearance the mark had against the
+     * body, scaled — so the frame width stays free to change.
+     */
+    private markBox;
+    /** The bright plate inside a selected seat's frame. */
+    protected corePath(placed: PlacedSeat): string;
+    protected coreFill(): string;
+    /** The dimming wash over a held or booked seat's type colour. */
+    protected washFill(placed: PlacedSeat): string;
+    /** The occupant figure for a marked seat, sized to whatever it sits on. */
+    protected occupantPath(placed: PlacedSeat): string;
+    protected occupantStroke(placed: PlacedSeat): number;
+    protected wheelchairCx(placed: PlacedSeat): number;
+    protected wheelchairCy(placed: PlacedSeat): number;
+    protected wheelchairRadius(placed: PlacedSeat): number;
+    /**
+     * A core-coloured outline behind a selected seat's number, painted under the
+     * glyphs via `paint-order`.
+     *
+     * The label is centred on the occupant's shoulder line, so without this it is
+     * `selectedBg` over a `selectedBg` silhouette — the figure, not the plate, is
+     * what it actually has to contrast against. The halo also rescues a label too
+     * long for the core, which would otherwise run onto the frame and vanish into
+     * it.
+     *
+     * Bound here rather than in the stylesheet on purpose: a CSS
+     * `var(--kerusi-selected-fg, …)` rule would carry the library default as its
+     * fallback and silently skip the `[colors]` input tier, which only the
+     * TypeScript side can resolve.
+     */
+    protected labelHalo(placed: PlacedSeat): string;
+    protected labelHaloWidth(placed: PlacedSeat): number;
+    /** Solid for selected/booked; `none` for held, which draws hollow instead. */
+    protected occupantFill(variant: SeatOccupantVariant): string;
+    protected occupantStrokeColor(variant: SeatOccupantVariant): string;
+    /** The section's single tab stop; every other seat is reachable by arrow key. */
+    protected tabIndex(placed: PlacedSeat): number;
+    protected ariaLabel(placed: PlacedSeat): string;
+    protected seatClasses(placed: PlacedSeat): string;
+    /** SVG rotate() about the item's center; null when it does not rotate. */
+    protected transform(item: PlacedSeat | PlacedElement): string | null;
+    /** Cancels the parent <g>'s rotation so the label stays upright and stays put. */
+    protected counterRotate(item: PlacedSeat | PlacedElement): string | null;
+    protected style(placed: PlacedElement): _kerusiweb_core.ElementStyle;
+    protected elementFillOf(placed: PlacedElement): string;
+    protected elementTextFillOf(placed: PlacedElement): string;
+    protected screenPathOf(placed: PlacedElement): string;
+    /** The corner radius for a rectangular element; a stage reads as squarer. */
+    protected radiusOf(placed: PlacedElement): number;
+    protected onSeatClick(placed: PlacedSeat): void;
+    protected onSeatFocus(placed: PlacedSeat): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KerusiSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KerusiSectionComponent, "kerusi-section", never, { "section": { "alias": "section"; "required": true; "isSignal": true; }; "layout": { "alias": "layout"; "required": true; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "focusedSeatId": { "alias": "focusedSeatId"; "required": false; "isSignal": true; }; "ariaLabels": { "alias": "ariaLabels"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "typeColors": { "alias": "typeColors"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "unitScale": { "alias": "unitScale"; "required": false; "isSignal": true; }; }, { "seatActivate": "seatActivate"; "seatFocused": "seatFocused"; "seatKeydown": "seatKeydown"; }, never, never, true, never>;
+}
+
+/** Which marks, beyond the body fill, a status swatch draws. */
+type StatusKind = 'plain' | 'blocked' | SeatOccupantVariant;
+/** One availability swatch in the legend's second block. */
+interface StatusEntry {
+    key: string;
+    label: string;
+    kind: StatusKind;
+    /** The swatch body's fill. */
+    fill: string;
+}
+/**
+ * A key for a seat map: its seat types on one side, its availability states on
+ * the other.
+ *
+ * This ships in the library rather than being left to each application because
+ * the swatch colors must come from the *same* resolution path as the seat
+ * fills — `SeatType.color` when the document supplies one, the theme's
+ * available color when it does not. Re-deriving that in application code is how
+ * a legend ends up disagreeing with the map it describes.
+ *
+ * It is opt-in: `<kerusi-seatmap [showLegend]="true">` renders it inline, or
+ * use `<kerusi-legend>` directly to place it anywhere.
+ */
+declare class KerusiLegendComponent {
+    /** From `RenderMap.legend`. */
+    readonly legend: _angular_core.InputSignal<readonly RenderLegendEntry[]>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly colors: _angular_core.InputSignal<Required<KerusiSeatmapColors>>;
+    /** Whether an available seat takes its type color — mirrors the seatmap input. */
+    readonly typeColors: _angular_core.InputSignal<boolean>;
+    readonly showPrices: _angular_core.InputSignal<boolean>;
+    /** Hide types no seat in the rendered map actually uses. */
+    readonly hideUnusedTypes: _angular_core.InputSignal<boolean>;
+    readonly headingSeatTypes: _angular_core.InputSignal<string>;
+    readonly headingAvailability: _angular_core.InputSignal<string>;
+    protected readonly types: _angular_core.Signal<RenderLegendEntry[]>;
+    protected readonly statuses: _angular_core.Signal<StatusEntry[]>;
+    protected swatch(entry: RenderLegendEntry): string;
+    protected swatchText(entry: RenderLegendEntry): string;
+    /** The swatch's viewBox edge; the seat glyph is drawn to fill it. */
+    protected readonly glyphSize = 16;
+    protected readonly glyphBody: string;
+    /** The selected swatch's frame width, and the core it leaves inside itself. */
+    private readonly glyphFrame;
+    private readonly glyphCoreSize;
+    protected readonly glyphCore: string;
+    protected readonly glyphOccupant: string;
+    protected readonly glyphOccupantStroke: number;
+    /** The selected swatch's figure sits on the core, so it is drawn to the core. */
+    private readonly glyphCoreOccupant;
+    private readonly glyphCoreOccupantStroke;
+    protected occupantPathOf(variant: SeatOccupantVariant): string;
+    protected occupantStrokeWidthOf(variant: SeatOccupantVariant): number;
+    protected hasWash(kind: StatusKind): kind is 'held' | 'booked';
+    protected hasOccupant(kind: StatusKind): kind is SeatOccupantVariant;
+    protected washFillOf(kind: 'held' | 'booked'): string;
+    protected occupantFillOf(variant: SeatOccupantVariant): string;
+    protected occupantStrokeOf(variant: SeatOccupantVariant): string;
+    protected coreFill(): string;
+    protected price(entry: RenderLegendEntry): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KerusiLegendComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KerusiLegendComponent, "kerusi-legend", never, { "legend": { "alias": "legend"; "required": true; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "typeColors": { "alias": "typeColors"; "required": false; "isSignal": true; }; "showPrices": { "alias": "showPrices"; "required": false; "isSignal": true; }; "hideUnusedTypes": { "alias": "hideUnusedTypes"; "required": false; "isSignal": true; }; "headingSeatTypes": { "alias": "headingSeatTypes"; "required": false; "isSignal": true; }; "headingAvailability": { "alias": "headingAvailability"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A signal-backed live view of a {@link KerusiState}.
+ *
+ * Construct it directly — `new KerusiStateStore(initialState)` — and feed it
+ * deltas from whatever transport you use. It is deliberately not an
+ * `@Injectable`: this is a rendering library, and an application that already
+ * owns its availability state should keep owning it.
+ */
+declare class KerusiStateStore {
+    private readonly _state;
+    private readonly _needsRefetch;
+    private readonly _now;
+    private readonly clock;
+    private readonly sequenceOf;
+    private lastSequence;
+    constructor(initial: KerusiState, opts?: {
+        now?: () => Date;
+        sequenceOf?: SequenceReader;
+    });
+    /** The current availability snapshot. */
+    get state(): Signal<KerusiState>;
+    /** The timestamp of the most recently applied document. */
+    readonly updatedAt: Signal<string>;
+    /**
+     * True once a gap was detected in the delta stream. The consumer SHOULD
+     * re-fetch a full `KerusiState` and hand it to {@link reset} (§5.2).
+     */
+    get needsRefetch(): Signal<boolean>;
+    /** Every currently-held seat, with the time left on its hold. */
+    readonly heldSeats: Signal<readonly HeldSeat[]>;
+    /** Offers a delta to the store. Returns what happened to it. */
+    apply(delta: KerusiStateDelta): DeltaApplication;
+    /**
+     * Replaces the state wholesale — the post-refetch path. Clears the
+     * refetch flag and forgets the delta sequence.
+     */
+    reset(state: KerusiState): void;
+    /** Reverts lapsed holds and refreshes `heldSeats` countdowns. */
+    tick(): void;
+    /**
+     * Runs {@link tick} on an interval. Returns a function that stops it — call
+     * that from `DestroyRef.onDestroy` or `ngOnDestroy`.
+     */
+    startExpiryTicker(intervalMs?: number): () => void;
+}
+
+export { KerusiLegendComponent, KerusiSeatmapComponent, KerusiSectionComponent, KerusiStateStore };
+export type { SeatDisallowed, SeatInteraction, SectionRenderOptions, ValidationMode };