@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/engine/defs.d.ts

@@ -0,0 +1,38 @@
+import { Box, Mesh, type Polygon, Rect, type TriangleIndex } from '@expofp/geometry';
+import { type ImageDef, type ImageSource, type LayerDef, type RenderableDefCollection, type SceneDef, type ShapeDef, type SharedDef, type TextAlignment, type TextDef, type TextLineDef } from '@expofp/renderer';
+/**
+ * What svgMesh3d puts on `window.__fpPaths`: vertices as bare number tuples, which is why this is
+ * not geometry's `MeshLike` — that one holds points. The third component is optional because
+ * svgMesh3d emits it per vertex and only sometimes.
+ */
+export interface MeshType {
+    positions: [number, number, number?][];
+    cells: TriangleIndex[];
+}
+export type TextLines = [string[], string[]];
+export interface FontSizeFactor {
+    scaleFactor: number;
+    value: number;
+    lines: string[];
+}
+export declare function rectToShapeDef(rect: SVGRectElement, color?: string): ShapeDef;
+export declare function meshToShapeDef(mesh: MeshType, color: string): ShapeDef;
+export declare function createShapeDef(shape: Box | Rect | Polygon | Mesh, color?: string): ShapeDef;
+export declare function createImageDef<Source extends ImageSource>(source: Source, bounds: Rect, options?: SharedDef & {
+    origin?: [number, number];
+}): ImageDef & {
+    source: Source;
+};
+export declare function createTextDef(textLines: TextLineDef[], bounds: Rect, padding: [number, number], alignment: TextAlignment, options?: SharedDef): TextDef;
+export declare function createTextDefLines(textLines: TextLines, color: string, fontSize: number, fontUrl?: [string | undefined, string | undefined]): TextLineDef[];
+export declare function createLayerDef(name: string, children: RenderableDefCollection, options?: SharedDef): LayerDef;
+export declare function createSceneDef(layers: LayerDef[], viewboxRect: Box | SVGRectElement, background?: string): SceneDef;
+export declare function createShapeDot(rect: Rect, color?: string, radius?: number): ImageDef & {
+    source: HTMLCanvasElement;
+};
+/**
+ * The CSS size a booth's dot is drawn at. For the drawers that receive a dot rather than create
+ * one, and so cannot read the radius it was made from.
+ */
+export declare const SHAPE_DOT_CSS_PX: number;
+//# sourceMappingURL=defs.d.ts.map

package/dist/esm/engine/defs.js

@@ -0,0 +1,85 @@
+import { Box, isBox, isMesh, isPolygon, isRect, Mesh, Rect, } from '@expofp/geometry';
+import { circleCanvasCssSize, createCircleCanvas } from '../components/Map/drawing/config/canvases';
+import { DEFAULT_FONT_LIGHT_URL, DEFAULT_FONT_URL } from './fonts';
+export function rectToShapeDef(rect, color) {
+    // The only callers pass an <rect> element; build a geometry Box and let
+    // createShapeDef convert it at the seam.
+    return createShapeDef(Box.fromSvg(rect), color);
+}
+export function meshToShapeDef(mesh, color) {
+    if (!mesh)
+        throw new Error('Create ShapeDef: mesh is not provided');
+    // A `Mesh`, not a `Polygon`: svgMesh3d emits positions that may carry a third component, varying
+    // per vertex, and only a Mesh can hold one. `Mesh.set` normalizes with `v.z ?? 0`, so an absent
+    // or undefined z needs no special casing here and a flat plan builds exactly the geometry it
+    // built before. `Math.abs` on y is the long-standing svgMesh3d correction (a quirk when
+    // `normalize: false`), applied on read.
+    //
+    // Note that `getTrianglesFromFpPaths` still truncates `window.__fpPaths` positions to two
+    // components in place, so a path it has already read reports z = 0 here — see the design spec's
+    // risk list. Deliberately left alone for now.
+    const vertices = mesh.positions.map((p) => ({ x: p[0], y: Math.abs(p[1]), z: p[2] ?? 0 }));
+    const indices = mesh.cells;
+    return createShapeDef(new Mesh(vertices, indices), color);
+}
+export function createShapeDef(shape, color = '#000') {
+    if (!shape || !(isBox(shape) || isRect(shape) || isPolygon(shape) || isMesh(shape))) {
+        throw new Error('Invalid shape definition');
+    }
+    return { shape, color };
+}
+export function createImageDef(source, bounds, options) {
+    if (!source)
+        throw new Error('Image source is not provided');
+    return { source, bounds, ...options };
+}
+export function createTextDef(textLines, bounds, padding, alignment, options) {
+    if (textLines.length === 0)
+        throw new Error('Invalid text lines');
+    return { lines: textLines, bounds, padding, alignment, ...options };
+}
+export function createTextDefLines(textLines, color, fontSize, fontUrl = [undefined, undefined]) {
+    const [mainLines, detailsLines] = textLines;
+    const lines = [
+        { text: mainLines.join('\n'), fontUrl: fontUrl[0] || DEFAULT_FONT_URL, color, fontSize },
+    ];
+    if (detailsLines.length) {
+        lines.push({
+            text: detailsLines.join('\n'),
+            fontUrl: fontUrl[1] || DEFAULT_FONT_LIGHT_URL,
+            color,
+            fontSize,
+        });
+    }
+    return lines;
+}
+export function createLayerDef(name, children, options) {
+    if (!name)
+        throw new Error('Layer name is required');
+    if (!children)
+        children = [];
+    return { name, children, ...options };
+}
+export function createSceneDef(layers, viewboxRect, background) {
+    const viewbox = viewboxRect instanceof Box ? viewboxRect : Box.fromSvg(viewboxRect);
+    return {
+        rootLayer: createLayerDef('root', layers),
+        background,
+        viewbox,
+    };
+}
+export function createShapeDot(rect, color = '#000', radius = SHAPE_DOT_RADIUS_PX) {
+    const source = createCircleCanvas(radius, color);
+    const cssSize = circleCanvasCssSize(radius);
+    // The dot stands in for the label on the same surface, so it takes the rect's elevation too:
+    // on an elevated booth that is the roof, and without it the dot would draw on the floor inside.
+    const bounds = new Rect(rect.center, { x: cssSize, y: cssSize }, rect.rotation, rect.elevation);
+    return createImageDef(source, bounds);
+}
+/** The radius of a booth's dot, in CSS pixels, when the caller does not name one. */
+const SHAPE_DOT_RADIUS_PX = 1.5;
+/**
+ * The CSS size a booth's dot is drawn at. For the drawers that receive a dot rather than create
+ * one, and so cannot read the radius it was made from.
+ */
+export const SHAPE_DOT_CSS_PX = circleCanvasCssSize(SHAPE_DOT_RADIUS_PX);

package/dist/esm/engine/fonts.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_FONT_URL: string;
+export declare const DEFAULT_FONT_LIGHT_URL: string;
+export interface CustomFonts {
+    weight: string;
+    style: string;
+    url: string;
+}
+export declare function loadCustomFontsUrls(): CustomFonts[];
+//# sourceMappingURL=fonts.d.ts.map

package/dist/esm/engine/fonts.js

@@ -0,0 +1,12 @@
+// @ts-nocheck
+import { getConfig } from '@expofp/config';
+import baseRuntimeUrl from '../tools/base-runtime-url';
+export const DEFAULT_FONT_URL = `${baseRuntimeUrl}fonts/oswald-v17-cyrillic_latin-500.woff`;
+export const DEFAULT_FONT_LIGHT_URL = `${baseRuntimeUrl}fonts/oswald-v17-cyrillic_latin-300.woff`;
+export function loadCustomFontsUrls() {
+    const data = getConfig();
+    if (data.customCssFonts?.length) {
+        return data.customCssFonts;
+    }
+    return [];
+}

package/dist/esm/engine/update-def.d.ts

@@ -0,0 +1,55 @@
+import { Rect } from '@expofp/geometry';
+import { type TextDef, type TextLineDef } from '@expofp/renderer';
+import { type FontSizeFactor } from './defs';
+export declare function updateLinesScale(lines: TextLineDef[], scale: number, fontSizes: [FontSizeFactor[], FontSizeFactor[]]): boolean;
+/**
+ * Turns a text def's bounds by whole quarter turns, in one write.
+ *
+ * Each quarter turn swaps width and height, and two swaps cancel out. So turning by `turns`
+ * quarters one at a time lands on the same rect as adding `turns · π/2` once and swapping only
+ * when `turns` is odd — no loop needed.
+ *
+ * The bounds are written in place, not replaced: the drawers keep references to them.
+ * @param textDef - The def to turn.
+ * @param turns - Signed number of quarter turns, as {@link getQuarterTurns} returns.
+ * @returns The same def.
+ */
+export declare function rotateTextDefByQuarters(textDef: TextDef, turns: number): TextDef;
+/**
+ * Turns a plain rect by whole quarter turns: the transform {@link rotateTextDefByQuarters} applies,
+ * where the swap-on-odd rule is explained. Returns a new rect, since nothing else holds this one.
+ * @param rect - The rect to turn.
+ * @param turns - Signed number of quarter turns, as {@link getQuarterTurns} returns.
+ * @returns The turned rect.
+ */
+export declare function rotateRectByQuarters(rect: Rect, turns: number): Rect;
+/**
+ * How many 90° steps a def is behind the camera, signed: the whole distance, so a camera that
+ * jumped is caught up with in one write.
+ * @param newAngle - The angle turned to, in radians.
+ * @param currentRotation - The angle turned from, in radians.
+ * @returns The signed number of quarters; `0` within 45° and for a non-finite angle.
+ */
+export declare function getQuarterTurns(newAngle: number, currentRotation: number): number;
+export declare function shouldFlip(newAngle: number, currentRotation: number): boolean;
+export declare function flipAngle(angle: number): number;
+/**
+ * Bounds for an image pinned to a booth's top-right corner, clamped to fit inside the booth.
+ * @param rect - The booth.
+ * @param size - The image's size at a scale of 1, in CSS pixels. Not a canvas's backing store: that
+ *   is in the device pixels it was rasterized at, which says how crisp the image is, not how big.
+ * @param padding - The booth's inset, in plan units.
+ * @param scale - Plan units per CSS pixel.
+ * @returns The bounds.
+ */
+export declare function getClampedBoundsCanvas(rect: Rect, size: {
+    readonly width: number;
+    readonly height: number;
+}, padding: number, scale: number): Rect;
+/**
+ * Reads the `roll` map setting — `1`/`0`, from the URL or the venue — as a boolean, refusing
+ * anything else. The label configs consult it before declaring their `onRoll` rules: with roll
+ * disabled the plan never turns, so a counter-rotation would only ever fight a stale angle.
+ */
+export declare function getRollValue(value: 1 | 0): boolean;
+//# sourceMappingURL=update-def.d.ts.map

package/dist/esm/engine/update-def.js

@@ -0,0 +1,127 @@
+import { angleDiff, Rect } from '@expofp/geometry';
+import { getBounds } from '../components/Map/drawing/config/canvases';
+export function updateLinesScale(lines, scale, fontSizes) {
+    let hasChanged = false;
+    lines.forEach((line, l) => {
+        let fontSize = 0;
+        fontSizes[l].forEach(({ value, scaleFactor }) => {
+            if (scale < scaleFactor)
+                fontSize = value;
+        });
+        if (line.fontSize !== fontSize * scale)
+            hasChanged = true;
+        line.fontSize = fontSize * scale;
+    });
+    return hasChanged;
+}
+/**
+ * Turns a text def's bounds by whole quarter turns, in one write.
+ *
+ * Each quarter turn swaps width and height, and two swaps cancel out. So turning by `turns`
+ * quarters one at a time lands on the same rect as adding `turns · π/2` once and swapping only
+ * when `turns` is odd — no loop needed.
+ *
+ * The bounds are written in place, not replaced: the drawers keep references to them.
+ * @param textDef - The def to turn.
+ * @param turns - Signed number of quarter turns, as {@link getQuarterTurns} returns.
+ * @returns The same def.
+ */
+export function rotateTextDefByQuarters(textDef, turns) {
+    const { center, size, rotation, elevation } = textDef.bounds;
+    const swap = turns % 2 !== 0;
+    textDef.bounds.set(center.x, center.y, swap ? size.y : size.x, swap ? size.x : size.y, rotation + (turns * Math.PI) / 2, elevation);
+    return textDef;
+}
+/**
+ * Turns a plain rect by whole quarter turns: the transform {@link rotateTextDefByQuarters} applies,
+ * where the swap-on-odd rule is explained. Returns a new rect, since nothing else holds this one.
+ * @param rect - The rect to turn.
+ * @param turns - Signed number of quarter turns, as {@link getQuarterTurns} returns.
+ * @returns The turned rect.
+ */
+export function rotateRectByQuarters(rect, turns) {
+    const { size, center, rotation, elevation } = rect;
+    const turnedSize = turns % 2 !== 0 ? { x: size.y, y: size.x } : size;
+    return new Rect(center, turnedSize, rotation + (turns * Math.PI) / 2, elevation);
+}
+/**
+ * How many 90° steps a def is behind the camera, signed: the whole distance, so a camera that
+ * jumped is caught up with in one write.
+ * @param newAngle - The angle turned to, in radians.
+ * @param currentRotation - The angle turned from, in radians.
+ * @returns The signed number of quarters; `0` within 45° and for a non-finite angle.
+ */
+export function getQuarterTurns(newAngle, currentRotation) {
+    if (!Number.isFinite(newAngle) || !Number.isFinite(currentRotation))
+        return 0;
+    const diff = angleDiff(newAngle, currentRotation);
+    if (Math.abs(diff) <= Math.PI / 4)
+        return 0;
+    return Math.round(diff / (Math.PI / 2));
+}
+export function shouldFlip(newAngle, currentRotation) {
+    const diff = angleDiff(newAngle, currentRotation);
+    const halfPi = Math.PI / 2;
+    const hysteresis = 0.1; // ~6°
+    return Math.abs(diff) > halfPi + hysteresis;
+}
+export function flipAngle(angle) {
+    const flipped = angle + Math.PI;
+    return ((flipped + Math.PI) % (2 * Math.PI)) - Math.PI;
+}
+/**
+ * Bounds for an image pinned to a booth's top-right corner, clamped to fit inside the booth.
+ * @param rect - The booth.
+ * @param size - The image's size at a scale of 1, in CSS pixels. Not a canvas's backing store: that
+ *   is in the device pixels it was rasterized at, which says how crisp the image is, not how big.
+ * @param padding - The booth's inset, in plan units.
+ * @param scale - Plan units per CSS pixel.
+ * @returns The bounds.
+ */
+export function getClampedBoundsCanvas(rect, size, padding, scale) {
+    const shapeWidth = size.width;
+    const shapeHeight = size.height;
+    const boothSize = rect.size;
+    const boothCenter = rect.center;
+    const boothRotation = rect.rotation;
+    const maxBookmarkWidth = boothSize.x;
+    const maxScaleByRectWidth = maxBookmarkWidth / shapeWidth;
+    const boothInnerWidth = boothSize.x - padding * 2;
+    const boothInnerHeight = boothSize.y - padding * 2;
+    const maxHeight = boothInnerHeight * 0.8;
+    const minScale = 0;
+    const maxScaleX = boothInnerWidth / shapeWidth;
+    const maxScaleY = maxHeight / shapeHeight;
+    const maxScale = Math.min(maxScaleX, maxScaleY, maxScaleByRectWidth);
+    scale = Math.min(Math.max(scale, minScale), maxScale);
+    const scaledWidth = shapeWidth * scale;
+    const scaledHeight = shapeHeight * scale;
+    const sin = Math.sin(boothRotation);
+    const cos = Math.cos(boothRotation);
+    const boothLocalX = boothSize.x / 2 - padding;
+    const boothLocalY = -boothSize.y / 2 + padding;
+    const boothTopRightX = boothCenter.x + boothLocalX * cos - boothLocalY * sin;
+    const boothTopRightY = boothCenter.y + boothLocalX * sin + boothLocalY * cos;
+    const canvasOffsetX = scaledWidth / 2;
+    const canvasOffsetY = -scaledHeight / 2;
+    const dx = canvasOffsetX * cos - canvasOffsetY * sin;
+    const dy = canvasOffsetX * sin + canvasOffsetY * cos;
+    const centerX = boothTopRightX - dx;
+    const centerY = boothTopRightY - dy;
+    // getBounds returns a geometry Rect; renderer consumes it directly. The booth's elevation rides
+    // along, so a ribbon on a raised booth sits on that booth's roof rather than dropping to the
+    // plan's floor.
+    return getBounds(centerX, centerY, shapeWidth, shapeHeight, scale, boothRotation, rect.elevation);
+}
+/**
+ * Reads the `roll` map setting — `1`/`0`, from the URL or the venue — as a boolean, refusing
+ * anything else. The label configs consult it before declaring their `onRoll` rules: with roll
+ * disabled the plan never turns, so a counter-rotation would only ever fight a stale angle.
+ */
+export function getRollValue(value) {
+    if (!value)
+        return false;
+    if (!Number.isInteger(+value) || (+value !== 1 && +value !== 0))
+        throw new Error('Map roll: setting value is incorrect');
+    return Boolean(+value);
+}

package/dist/esm/engine/utils/rotation.d.ts

@@ -0,0 +1,13 @@
+import type { Rect, RectLike } from '@expofp/geometry';
+import type { ImageDef } from '@expofp/renderer';
+export declare function isInnerInsideOuter(inner: Rect, outer?: RectLike): boolean;
+export declare function flipImageDef(imageDef: ImageDef, angle: number): boolean;
+/**
+ * Declares the camera-roll rule on a def that has to stay readable: it follows the plan in quarter
+ * turns, the same way the plan's own labels do.
+ * @param imageDef - The def to keep upright.
+ * @returns The same def.
+ */
+export declare function attachCardinalSnap(imageDef: ImageDef): ImageDef;
+export declare function rotateImageDef(imageDef: ImageDef, angle: number): boolean;
+//# sourceMappingURL=rotation.d.ts.map

package/dist/esm/engine/utils/rotation.js

@@ -0,0 +1,73 @@
+import { flipAngle, getQuarterTurns, shouldFlip } from '../update-def';
+// check if inner stays in outer rect on 90 deg rotation
+export function isInnerInsideOuter(inner, outer) {
+    // TODO: to use it we need to implement transparent pixel check to define non square images but set as square in SVG
+    // Check if the inner rect is nearly square (within ±10 px tolerance)
+    // const diff = Math.abs(inner.size.x - inner.size.y);
+    // if (diff <= 10) return true;
+    if (!outer)
+        return false;
+    // Translate each corner relative to outer.center, rotate by -outer.rotation, then compare against outer's axis-aligned half-extents.
+    const cos = Math.cos(outer.rotation ?? 0);
+    const sin = Math.sin(outer.rotation ?? 0);
+    const halfWidth = outer.size.x / 2;
+    const halfHeight = outer.size.y / 2;
+    return getRectCorners(inner, inner.rotation + Math.PI / 2).every((corner) => {
+        const dx = corner.x - outer.center.x;
+        const dy = corner.y - outer.center.y;
+        const rotatedX = dx * cos + dy * sin;
+        const rotatedY = dy * cos - dx * sin;
+        return Math.abs(rotatedX) <= halfWidth && Math.abs(rotatedY) <= halfHeight;
+    });
+}
+function getRectCorners(r, rotation = r.rotation) {
+    const hw = r.size.x / 2;
+    const hh = r.size.y / 2;
+    const s = Math.sin(rotation);
+    const c = Math.cos(rotation);
+    const cx = r.center.x;
+    const cy = r.center.y;
+    const pts = [
+        { x: -hw, y: -hh },
+        { x: hw, y: -hh },
+        { x: hw, y: hh },
+        { x: -hw, y: hh },
+    ];
+    return pts.map((p) => ({
+        x: cx + p.x * c - p.y * s,
+        y: cy + p.x * s + p.y * c,
+    }));
+}
+// Geometry Rect is immutable via getters, but `rotate(…, target)` mutates in
+// place. These bounds are owned by the def and read only by the renderer's
+// per-frame sync, so mutating in place is safe and avoids per-frame allocation
+// on the hot path. Both return whether they moved the def, so an `onRoll`
+// built on them can skip the write when nothing changed.
+export function flipImageDef(imageDef, angle) {
+    const b = imageDef.bounds;
+    if (!shouldFlip(angle, b.rotation))
+        return false;
+    // Rotate to the flipped angle: rotate() adds a delta, so aim for flipAngle(current).
+    b.rotate(flipAngle(b.rotation) - b.rotation, b);
+    return true;
+}
+/**
+ * Declares the camera-roll rule on a def that has to stay readable: it follows the plan in quarter
+ * turns, the same way the plan's own labels do.
+ * @param imageDef - The def to keep upright.
+ * @returns The same def.
+ */
+export function attachCardinalSnap(imageDef) {
+    imageDef.onRoll = ({ roll }) => (rotateImageDef(imageDef, roll) ? [imageDef] : undefined);
+    return imageDef;
+}
+// Every quarter at once, so a def catches up with a camera that jumped: the roll record gives it no
+// second chance to do so.
+export function rotateImageDef(imageDef, angle) {
+    const b = imageDef.bounds;
+    const turns = getQuarterTurns(angle, b.rotation);
+    if (turns === 0)
+        return false;
+    b.rotate((turns * Math.PI) / 2, b); // out-parameter: rotation += delta, in place
+    return true;
+}

package/dist/esm/floorplan.loader.d.ts

@@ -0,0 +1,164 @@
+import { type Consent } from '@expofp/config';
+import { type Camera, type ListPanel, type PlannerOptions, type SessionsFilters } from '@expofp/schema';
+import { type InternalSettings } from './internal-settings.js';
+import type { CurrentPosition, Floor, FloorPlan, FloorPlanBookmarkClickEvent, FloorPlanBoothClickEvent, FloorPlanCategory, FloorPlanCustomButtonEvent, FloorPlanDetailsEvent, FloorPlanDirectionEvent, FloorPlanExternalNavigationEvent, FloorPlanGetCoordsEvent, FloorPlanIcon, FloorPlanMarkerEvent, FloorPlanOptions, FloorPlanVisitedClickEvent, GeoConfig, MaplibreOptions, MarkersData, RouteInfo, RouteWaypoint, Venue, VenueDiagnostic, Visibility } from './types';
+import { type Bounds, type POISelectors } from './types/sdk.types';
+/**
+ * A host element carries the plan occupying it, so a second `load()` into the
+ * same container can be refused and {@link FloorPlan.destroy} can hand the
+ * element back by clearing the mark.
+ */
+export type FloorPlanHostElement = HTMLDivElement & {
+    __expofp?: FloorPlan;
+};
+/** Rejection reason for {@link FloorPlan.ready} when the plan is destroyed mid-load. */
+export declare const DESTROYED_BEFORE_READY = "FloorPlan destroyed before it finished loading";
+export default class FloorPlanLoader implements FloorPlan {
+    protected readonly renderTarget: HTMLDivElement;
+    private readonly _ready;
+    readonly element: HTMLDivElement;
+    readonly eventId: string;
+    readonly noOverlay: boolean;
+    readonly offHistory: boolean;
+    readonly ignoreQuery: boolean;
+    protected readonly consent: Consent;
+    readonly onInit: (fp: FloorPlan) => void;
+    readonly disableRuntimeAlerts: boolean;
+    readonly viewerMode: boolean;
+    readonly maplibre: MaplibreOptions | undefined;
+    /** Called with an event by the `__efpStyleLoad` listener, and bare to drain the registry on construction. */
+    protected efpStyleLoadHandler: (e?: Event) => void;
+    protected resolveReady: () => void;
+    /** Counterpart of {@link resolveReady}, called by {@link destroy}; same assignment caveat. */
+    protected rejectReady: (reason: Error) => void;
+    readonly icons: Map<FloorPlanIcon, HTMLImageElement>;
+    enableRotation: boolean;
+    alwaysShowSidebar: boolean;
+    /** Set by {@link destroy}; checked by `init()` so a plan destroyed mid-load never mounts. */
+    protected destroyed: boolean;
+    get ready(): Promise<void>;
+    get previewMode(): boolean;
+    /** @deprecated The consent decision lives on the config — set the `consent` option instead. */
+    get allowConsent(): boolean | undefined;
+    /** Grey surface for mobile SDKs — see internal-settings.ts; deliberately not on `FloorPlan`. */
+    getInternalSettings(): InternalSettings;
+    onBoothClick: (e: FloorPlanBoothClickEvent) => void;
+    onBookmarkClick: (e: FloorPlanBookmarkClickEvent) => void;
+    onVisitedClick: (e: FloorPlanVisitedClickEvent) => void;
+    onCategoryClick: (e: FloorPlanCategory) => void;
+    onFpConfigured: () => void;
+    onDirection: (e: FloorPlanDirectionEvent | null) => void;
+    onDetails: (e: FloorPlanDetailsEvent) => void;
+    onExhibitorCustomButtonClick: (e: FloorPlanCustomButtonEvent) => void;
+    onGetCoordsClick: (e: FloorPlanGetCoordsEvent) => void;
+    onMarkerClick: (e: FloorPlanMarkerEvent) => void;
+    onExternalNavigation?: (e: FloorPlanExternalNavigationEvent) => void;
+    onLeaveEvent?: () => void;
+    selectBooth(nameOrExternalId: string | string[]): void;
+    selectExhibitor(nameOrExternalId: string | string[]): void;
+    selectRoute(startOrWaypoints: RouteWaypoint | RouteWaypoint[], to?: RouteWaypoint): void;
+    getOptimizedRoutes(waypoints: RouteWaypoint[]): RouteInfo[];
+    selectCurrentPosition(point: CurrentPosition, focus: boolean, icon?: number): void;
+    setBookmarks(bookmarks: {
+        name?: string;
+        externalId?: string;
+        bookmarked: boolean;
+    }[]): void;
+    setEntitiesBookmarks(bookmarks: {
+        type: 'exhibitor' | 'event' | 'speaker' | 'booth';
+        name?: string;
+        externalId?: string;
+        bookmarked: boolean;
+    }[]): void;
+    setEntitiesVisited(entities: {
+        type: 'exhibitor' | 'event';
+        name?: string;
+        externalId?: string;
+        visited: boolean;
+    }[]): void;
+    setMarkers(markersData: MarkersData): void;
+    /** @deprecated Use activateFloor instead */
+    updateLayerVisibility(layer: string, visible: boolean): void;
+    getCenterCoordinates(): any;
+    applyParameters(parameters: string): void;
+    exhibitorsList(): any;
+    boothsList(): any;
+    categoriesList(): any;
+    selectCategory(nameOrSlug?: string): void;
+    select(slugOrExternalId: string): void;
+    showList(list: ListPanel): void;
+    showSessions(filters?: SessionsFilters): void;
+    selectTour(tourId: string): void;
+    openPlanner(options?: PlannerOptions): void;
+    startBuildRoute(): void;
+    getVisibility(): any;
+    setVisibility(visibility: Visibility): void;
+    findLocation(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    zoomTo(selector: POISelectors, options?: {
+        padding?: number;
+    }): void;
+    switchView(): void;
+    setCamera(camera: Camera): void;
+    getCamera(): Camera;
+    fitBounds(): void;
+    getBounds(selectors: POISelectors): Bounds | undefined;
+    getBoothRect(name: string): any;
+    convertToGeo(x: number, y: number): any;
+    getGeoConfig(): GeoConfig | null;
+    /**
+     * Ends the live plan: dispose only — nothing is rebuilt here, because the
+     * config singleton still holds the dying event (ADR-0011). The next `load()`
+     * constructs the fresh world.
+     *
+     * Raises the `destroyed` flag — which the pending `init()` checks before it
+     * mounts anything — settles {@link ready}, then hands the state-specific
+     * teardown to {@link releaseResources}. The guard lives here so both states
+     * are idempotent through one implementation, and a host may call it
+     * defensively from a framework unmount hook.
+     */
+    destroy(): void;
+    /** @deprecated Renamed to {@link destroy}. */
+    unstable_destroy(): void;
+    /**
+     * Undoes the constructor's side effects — the teardown for a plan destroyed
+     * while still loading, where there is no mounted UI yet.
+     *
+     * `FloorPlanReady` overrides this to unwind the mounted plan first, then
+     * calls back here through `super`.
+     */
+    protected releaseResources(): void;
+    highlightExhibitors(externalIds: string[]): void;
+    highlightBooths(externalIds: string[]): void;
+    onCurrentPositionChanged(point: CurrentPosition): void;
+    search(term: string): Promise<{
+        item: unknown;
+        score: number;
+    }[]>;
+    getFloors(): Floor[];
+    onFloorActivated(floor: Floor): void;
+    getVenues(): Venue[];
+    getVenueDiagnostics(): VenueDiagnostic[];
+    onVenueActivated(venue: Venue): void;
+    activateVenue(venueId: {
+        id: string;
+    }): void;
+    activateFloor(floorId: {
+        name?: string;
+        index?: number;
+    }): void;
+    showPathway(name: string, boothExternalIds: string[]): void;
+    showPathwayOnly(pathwayId: string, floorId: string): void;
+    hidePathways(): void;
+    showSearch(): void;
+    changeLanguage(langId: string): void;
+    isGpsTrackingEnabled(): boolean;
+    setGpsTrackingEnabled(value: boolean): void;
+    deselectCurrentPosition(): void;
+    deselectRoute(): void;
+    reset(): void;
+    selectAccessibleRoute(waypoints: RouteWaypoint[]): void;
+    constructor(options: FloorPlanOptions, element: HTMLDivElement);
+}
+//# sourceMappingURL=floorplan.loader.d.ts.map