@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/floorplan.loader.js

@@ -0,0 +1,540 @@
+import { getConfig } from '@expofp/config';
+import { PREVIEW_MODE_ATTRIBUTE } from './constants';
+import { withPreloadedVenueScenes } from './data/venue-scene-preload';
+import { toInternalSettings } from './internal-settings.js';
+import { disposePlan } from './plan-lifecycle.js';
+// import { initOfflineManager } from "./offline/offlineManager";
+import baseRuntimeUrl from './tools/base-runtime-url';
+import { loadCss, loadFont } from './tools/loaders';
+import logger from './tools/logger';
+import { resetGlobalVariables } from './tools/reset';
+import { initSentry } from './tools/sentry';
+import { parkRegisteredStyles } from './tools/style-registry.js';
+import { heatmapEnabled } from './utils/heatmap-enabled';
+import { initI18n } from './utils/i18n';
+import isDebug from './utils/is-debug';
+import isLocalhost from './utils/is-localhost';
+import isWebview from './utils/is-webview';
+import { loadCustomCss } from './utils/loadCustomCss';
+import { loadIcons } from './utils/loadIcons';
+import useShadow from './utils/use-shadow';
+// ET: 2025-12-12 cannot use static import so far
+// import FloorPlanReady from "./floorplan.ready";
+function nr() {
+    throw new Error('FloorPlan not ready');
+}
+/** Rejection reason for {@link FloorPlan.ready} when the plan is destroyed mid-load. */
+export const DESTROYED_BEFORE_READY = 'FloorPlan destroyed before it finished loading';
+export default class FloorPlanLoader {
+    get ready() {
+        return this._ready;
+    }
+    get previewMode() {
+        return getConfig().previewMode || this.element.hasAttribute(PREVIEW_MODE_ATTRIBUTE);
+    }
+    /** @deprecated The consent decision lives on the config — set the `consent` option instead. */
+    get allowConsent() {
+        return this.consent === 'ask' ? undefined : this.consent === 'granted';
+    }
+    /** Grey surface for mobile SDKs — see internal-settings.ts; deliberately not on `FloorPlan`. */
+    getInternalSettings() {
+        return toInternalSettings(getConfig());
+    }
+    selectBooth(nameOrExternalId) {
+        nr();
+    }
+    selectExhibitor(nameOrExternalId) {
+        nr();
+    }
+    selectRoute(startOrWaypoints, to) {
+        nr();
+    }
+    getOptimizedRoutes(waypoints) {
+        nr();
+    }
+    selectCurrentPosition(point, focus, icon) {
+        nr();
+    }
+    setBookmarks(bookmarks) {
+        nr();
+    }
+    setEntitiesBookmarks(bookmarks) {
+        nr();
+    }
+    setEntitiesVisited(entities) {
+        nr();
+    }
+    setMarkers(markersData) {
+        nr();
+    }
+    /** @deprecated Use activateFloor instead */
+    updateLayerVisibility(layer, visible) {
+        nr();
+    }
+    getCenterCoordinates() {
+        nr();
+    }
+    applyParameters(parameters) {
+        nr();
+    }
+    exhibitorsList() {
+        nr();
+    }
+    boothsList() {
+        nr();
+    }
+    categoriesList() {
+        nr();
+    }
+    selectCategory(nameOrSlug) {
+        nr();
+    }
+    select(slugOrExternalId) {
+        nr();
+    }
+    showList(list) {
+        nr();
+    }
+    showSessions(filters) {
+        nr();
+    }
+    selectTour(tourId) {
+        nr();
+    }
+    openPlanner(options) {
+        nr();
+    }
+    startBuildRoute() {
+        nr();
+    }
+    getVisibility() {
+        nr();
+    }
+    setVisibility(visibility) {
+        nr();
+    }
+    findLocation() {
+        nr();
+    }
+    zoomIn() {
+        nr();
+    }
+    zoomOut() {
+        nr();
+    }
+    zoomTo(selector, options) {
+        nr();
+    }
+    switchView() {
+        nr();
+    }
+    setCamera(camera) {
+        nr();
+    }
+    getCamera() {
+        nr();
+    }
+    fitBounds() {
+        nr();
+    }
+    getBounds(selectors) {
+        nr();
+    }
+    getBoothRect(name) {
+        nr();
+    }
+    convertToGeo(x, y) {
+        nr();
+    }
+    getGeoConfig() {
+        nr();
+    }
+    /**
+     * 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() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        // A no-op once ready has resolved; before that it releases callers parked
+        // on `await plan.ready`, who would otherwise wait on an init that has
+        // already been cancelled.
+        this.rejectReady(new Error(DESTROYED_BEFORE_READY));
+        // `finally`, because releasing the page is what makes the *next* `load()`
+        // possible: a teardown that throws half way through must still surrender
+        // the plan slot, or the host is stuck with a plan it can neither use nor
+        // replace.
+        try {
+            this.releaseResources();
+        }
+        finally {
+            // Last: every MobX reaction, listener and timer the plan owns, then the
+            // store graph itself. After this the barrel is in its dead window and
+            // any stray late access throws instead of reading the dead event.
+            disposePlan();
+        }
+    }
+    /** @deprecated Renamed to {@link destroy}. */
+    unstable_destroy() {
+        this.destroy();
+    }
+    /**
+     * 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`.
+     */
+    releaseResources() {
+        window.removeEventListener('__efpStyleLoad', this.efpStyleLoadHandler);
+        // The chunk stylesheets outlive the plan on purpose (see the adoption
+        // comment in the constructor), but they must not take the container with
+        // them: emptying `this.element` below detaches the shadow root, and while
+        // one adopted `<style>` still has it as a parent the registry roots the
+        // whole dead tree from `window`.
+        parkRegisteredStyles();
+        // The shadow container and any loader spinners — everything the SDK put
+        // inside the host element. The host element itself belongs to the caller.
+        while (this.element.firstChild) {
+            this.element.removeChild(this.element.firstChild);
+        }
+        // Without this the element stays flagged as taken and a subsequent
+        // load() into the same container throws 'Element already in use'.
+        delete this.element.__expofp;
+        // Clears the `__efp*` / `__fp*` globals the constructor and the chunks
+        // write. They are page-wide rather than per-plan, so like the ready-state
+        // teardown this assumes one plan on the page at a time.
+        resetGlobalVariables();
+    }
+    highlightExhibitors(externalIds) {
+        nr();
+    }
+    highlightBooths(externalIds) {
+        nr();
+    }
+    onCurrentPositionChanged(point) {
+        nr();
+    }
+    search(term) {
+        nr();
+    }
+    getFloors() {
+        nr();
+    }
+    onFloorActivated(floor) {
+        nr();
+    }
+    getVenues() {
+        nr();
+    }
+    getVenueDiagnostics() {
+        nr();
+    }
+    onVenueActivated(venue) {
+        nr();
+    }
+    activateVenue(venueId) {
+        nr();
+    }
+    activateFloor(floorId) {
+        nr();
+    }
+    showPathway(name, boothExternalIds) {
+        nr();
+    }
+    showPathwayOnly(pathwayId, floorId) {
+        nr();
+    }
+    hidePathways() {
+        nr();
+    }
+    showSearch() {
+        nr();
+    }
+    changeLanguage(langId) {
+        nr();
+    }
+    isGpsTrackingEnabled() {
+        nr();
+    }
+    setGpsTrackingEnabled(value) {
+        nr();
+    }
+    deselectCurrentPosition() {
+        nr();
+    }
+    deselectRoute() {
+        nr();
+    }
+    reset() {
+        nr();
+    }
+    selectAccessibleRoute(waypoints) {
+        nr();
+    }
+    // protected _addCustomCss = async () => { };
+    constructor(options, element) {
+        // overwritten synchronously by the Promise executor in the constructor; a
+        // definite-assignment `!` would break the Babel legacy-decorator pipeline
+        this.resolveReady = () => undefined;
+        /** Counterpart of {@link resolveReady}, called by {@link destroy}; same assignment caveat. */
+        this.rejectReady = () => undefined;
+        this.icons = new Map();
+        this.enableRotation = true;
+        this.alwaysShowSidebar = false;
+        /** Set by {@link destroy}; checked by `init()` so a plan destroyed mid-load never mounts. */
+        this.destroyed = false;
+        const config = getConfig();
+        this.noOverlay = !!config.noOverlay;
+        this.offHistory = !!config.offHistory;
+        this.ignoreQuery = config.ignoreQuery;
+        // The environment settles an *undecided* consent only — an explicit
+        // 'granted'/'denied' from the config always wins. Webviews: the native
+        // app owns the consent UI. Localhost: keep dev sessions out of analytics.
+        this.consent = config.consent;
+        if (this.consent === 'ask') {
+            if (isWebview)
+                this.consent = 'granted';
+            else if (isLocalhost && !isDebug)
+                this.consent = 'denied';
+        }
+        // `FloorPlan` declares the callbacks required while the options are
+        // optional — the runtime tolerates undefined (call sites guard), so the
+        // non-null assertions preserve the legacy contract as-is.
+        this.onBoothClick = options.onBoothClick;
+        this.onBookmarkClick = options.onBookmarkClick;
+        this.onVisitedClick = options.onVisitedClick;
+        this.onCategoryClick = options.onCategoryClick;
+        this.onDetails = options.onDetails;
+        this.onExhibitorCustomButtonClick = options.onExhibitorCustomButtonClick;
+        this.onGetCoordsClick = options.onGetCoordsClick;
+        this.onMarkerClick = options.onMarkerClick;
+        this.onExternalNavigation = options.onExternalNavigation;
+        this.onFpConfigured = options.onFpConfigured;
+        this.onDirection = options.onDirection;
+        this.onInit = options.onInit;
+        this.onCurrentPositionChanged = options.onCurrentPositionChanged;
+        this.onFloorActivated = options.onFloorActivated;
+        this.onVenueActivated = options.onVenueActivated;
+        this.onLeaveEvent = options.onLeaveEvent;
+        this.viewerMode = !!config.viewerMode;
+        this.disableRuntimeAlerts = config.disableRuntimeAlerts;
+        this.maplibre = config.maplibre;
+        window['__efpMaplibre'] = config.maplibre;
+        this._ready = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+        // Awaiting `ready` is optional, so a destroy-before-ready rejection would
+        // otherwise surface as an unhandled rejection for every caller who never
+        // touched the promise. Consumers that do await it still see the error.
+        this._ready.catch(() => undefined);
+        this.element = element;
+        const elementSlot = element;
+        if (elementSlot.__expofp)
+            throw new Error('Element already in use');
+        elementSlot.__expofp = this;
+        const eventId = config.expo;
+        initSentry({ eventId: eventId || '', isWebview });
+        this.eventId = eventId;
+        window['__efpEvent'] = eventId;
+        window['__efpElement'] = element;
+        const shadowContainer = document.createElement('div');
+        shadowContainer.style.height = '100%';
+        shadowContainer.style.width = '100%';
+        element.appendChild(shadowContainer);
+        let container;
+        if (useShadow) {
+            container = shadowContainer.attachShadow({ mode: 'open' });
+            const containerObj = container;
+            const docObj = document;
+            containerObj.createElement = (...args) => docObj.createElement(...args);
+            containerObj.createElementNS = (...args) => docObj.createElementNS(...args);
+            containerObj.createTextNode = (...args) => docObj.createTextNode(...args);
+        }
+        else {
+            container = shadowContainer;
+        }
+        const fpContainer = document.createElement('div');
+        fpContainer.style.height = '100%';
+        fpContainer.style.width = '100%';
+        container.appendChild(fpContainer);
+        if (useShadow) {
+            Object.defineProperty(fpContainer, 'ownerDocument', { value: container });
+        }
+        window['__efpShadowDOMStyleParent'] = useShadow ? container : undefined;
+        this.renderTarget = fpContainer;
+        // lazy load floorplan and instantiate it here
+        logger.log('Instantiating ExpoFP floorplan', element, eventId);
+        let handledStyleElements = 0;
+        this.efpStyleLoadHandler = function (e) {
+            const elements = (window['__efpStyleElements'] ?? []);
+            while (handledStyleElements < elements.length) {
+                const el = elements[handledStyleElements];
+                container.appendChild(el);
+                handledStyleElements++;
+            }
+        };
+        window.addEventListener('__efpStyleLoad', this.efpStyleLoadHandler);
+        // Adopt the styles registered by chunks that have already evaluated. On a
+        // first load the registry is empty and every chunk announces itself; on a
+        // remount nothing announces anything — the chunks are cached, so waiting on
+        // the event alone leaves this container unstyled (`appendChild` moves each
+        // element out of the previous, discarded container).
+        this.efpStyleLoadHandler();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        (async function init() {
+            // the effective config IS the event data — one frozen document for
+            // everyone (drawing and wayfinding graph included, loaded by loadConfig)
+            const data = getConfig();
+            await initI18n();
+            if (self.destroyed)
+                return;
+            const searchParams = new URLSearchParams(window.location.search);
+            let trackerUrl;
+            let expoId;
+            if (data?.trackerUrl) {
+                try {
+                    trackerUrl = new URL(data.trackerUrl);
+                    expoId = trackerUrl.searchParams.get('expoId');
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            }
+            const initHeatmap = async (o) => {
+                if (!trackerUrl || !expoId) {
+                    return Promise.reject(new Error('trackerUrl or expoId is missing'));
+                }
+                const url = new URL(o.dataUrl, trackerUrl.origin);
+                const resp = await fetch(url.toString(), {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        expoId,
+                        token: decodeURIComponent(searchParams.get('t') ?? ''),
+                    }),
+                });
+                let yah = [];
+                if (resp.ok) {
+                    const json = await resp.json();
+                    yah = json.map(o.dataMapper);
+                }
+                window['__heatmapDataYah'] = { yah };
+            };
+            // Heatmap mode: `config.heatmap` is the canonical switch
+            // (?heatmap[variant]=yah, the manifest); the legacy
+            // ?heatmap=true&type=yah&subtype=kiosk params keep working as aliases —
+            // the legacy scalar never reaches the config node, so it is OR-ed in
+            // here. The access token `?t=` is request material, not config: it
+            // stays a raw query read (retirement plan §4.8).
+            const heatmap = data?.heatmap ?? {};
+            const heatmapOn = heatmapEnabled(heatmap) || searchParams.get('heatmap') === 'true';
+            const heatmapYah = heatmap.variant === 'yah' || searchParams.get('type') === 'yah';
+            const heatmapKiosk = heatmap.kiosk === true || searchParams.get('subtype') === 'kiosk';
+            if (heatmapOn) {
+                try {
+                    if (heatmapYah) {
+                        if (heatmapKiosk) {
+                            await initHeatmap({
+                                dataUrl: '/api/kiosks/list/viewer',
+                                dataMapper: (item) => ({ ...item, id: item.key, name: `Kiosk ${item.key}` }),
+                            });
+                        }
+                        else {
+                            await initHeatmap({
+                                dataUrl: '/api/v1/you-are-here/qr-code/list/viewer',
+                                dataMapper: (item, i) => ({ ...item, name: `QR Code #${i + 1}` }),
+                            });
+                        }
+                    }
+                    else {
+                        if (!trackerUrl || !expoId) {
+                            throw new Error('trackerUrl or expoId is missing');
+                        }
+                        const boothsUrl = new URL('/api/fp-stats/get', trackerUrl.origin);
+                        boothsUrl.searchParams.set('expoId', expoId);
+                        boothsUrl.searchParams.set('type', 'booview');
+                        boothsUrl.searchParams.set('t', decodeURIComponent(searchParams.get('t') ?? ''));
+                        const exhibitorsUrl = new URL('api/fp-stats/get', trackerUrl.origin);
+                        exhibitorsUrl.searchParams.set('expoId', expoId);
+                        exhibitorsUrl.searchParams.set('type', 'exview');
+                        exhibitorsUrl.searchParams.set('t', decodeURIComponent(searchParams.get('t') ?? ''));
+                        const [boothsResp, exhibitorsResp] = await Promise.all([
+                            fetch(boothsUrl.toString()),
+                            fetch(exhibitorsUrl.toString()),
+                        ]);
+                        const [booths, exhibitors] = await Promise.all([
+                            boothsResp.json(),
+                            exhibitorsResp.json(),
+                        ]);
+                        window['__heatmapData'] = { booths, exhibitors };
+                    }
+                }
+                catch (err) {
+                    console.error('Heatmap: Initialization error', err);
+                }
+            }
+            // rebooking state is merged by loadConfig (see @expofp/config rebooking.ts)
+            const promisesPart2 = [
+                loadCss(baseRuntimeUrl + 'vendor/sanitize-css/sanitize.css', container),
+                loadCss(baseRuntimeUrl + 'vendor/perfect-scrollbar/css/perfect-scrollbar.css', container),
+                loadFont('Oswald', baseRuntimeUrl + 'fonts/oswald-v17-cyrillic_latin-300.woff', {
+                    weight: 300,
+                }),
+                loadFont('Oswald', baseRuntimeUrl + 'fonts/oswald-v17-cyrillic_latin-500.woff', {
+                    weight: 500,
+                }),
+                loadFont('Inter', baseRuntimeUrl + 'fonts/inter-400.woff2', { weight: 400 }),
+                loadFont('Inter', baseRuntimeUrl + 'fonts/inter-500.woff2', { weight: 500 }),
+                loadFont('Inter', baseRuntimeUrl + 'fonts/inter-600.woff2', { weight: 600 }),
+                loadFont('efp-symbols', baseRuntimeUrl + 'fonts/efp-symbols.woff', { weight: 400 }),
+                loadCustomCss(data, container),
+                loadIcons(self.icons),
+            ];
+            await Promise.all(promisesPart2);
+            if (self.destroyed)
+                return;
+            self.enableRotation = data?.enableRotation ?? false;
+            self.alwaysShowSidebar = data?.alwaysShowSidebar ?? false;
+            logger.log('Data loaded');
+            // The event-scoped world is built here, not at module scope: `load()` has
+            // already installed this event's config and swept the previous plan's
+            // caches, so every store reads the event it belongs to (ADR-0011). Kept
+            // behind the dynamic import so the graph stays out of the loader chunk.
+            // The replacing venue scenes load first: `createLivePlan()` reads them.
+            const { createLivePlan, FloorPlanReady } = await withPreloadedVenueScenes(data, async () => {
+                const { createLivePlan } = await import(
+                /* webpackChunkName: "floorplan" */ './store/create-live-plan.js');
+                // ET: 2025-12-12 cannot remove dynamic import, seems not helping us here
+                const { default: FloorPlanReady } = await import(
+                /* webpackChunkName: "floorplan" */ './floorplan.ready.js');
+                return { createLivePlan, FloorPlanReady };
+            });
+            // A plan destroyed while its data or its chunks were still loading owns
+            // nothing yet, and must not start owning anything now: `destroy()` has
+            // already released the page, so building the graph — or mounting into an
+            // element the caller has discarded — would hand the barrel a world
+            // nobody will ever tear down. Checked after the imports settle, which is
+            // the last point the host can have slipped a `destroy()` in.
+            if (self.destroyed)
+                return;
+            createLivePlan();
+            // The loaders are *not* removed here. Nothing has drawn yet at this point — React has not
+            // mounted, the canvas does not exist — so clearing them leaves the host element empty for
+            // about half a second. `FloorPlanReady` clears them once the layers are loaded instead.
+            //const fp = new FloorPlanReady.default(options);
+            const fpReady = Object.setPrototypeOf(self, FloorPlanReady.prototype);
+            fpReady.init();
+        })();
+    }
+}

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

@@ -0,0 +1,149 @@
+import { Box } from '@expofp/geometry';
+import { type Camera, type ListPanel, type PlannerOptions, type SessionsFilters } from '@expofp/schema';
+import { createRoot } from 'react-dom/client';
+import FloorPlanLoader from './floorplan.loader';
+import { type CurrentPosition, type MarkersData } from './store/RouteStore';
+import { type Visibility } from './store/types';
+import type { Floor, FloorPlanBooth, FloorPlanCategory, FloorPlanExhibitor, FloorPlanGetCoordsEvent, GeoConfig, RouteInfo, RouteWaypoint, Venue, VenueDiagnostic } from './types';
+import { type Bounds, type POISelectors } from './types/sdk.types';
+export default class FloorPlanReady extends FloorPlanLoader {
+    root?: ReturnType<typeof createRoot>;
+    protected init(): void;
+    selectBooth(nameOrExternalId: string | string[]): void;
+    selectExhibitor(nameOrExternalId: string | string[]): void;
+    highlightExhibitors(externalIds: string[]): void;
+    highlightBooths(externalIds: string[]): void;
+    highlightEntities(externalIds: 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;
+    selectMarker(id: string, focus?: boolean): Promise<void>;
+    drawCircles(circles: {
+        x: number;
+        y: number;
+        radius: number;
+        color?: string;
+    }[]): void;
+    checkRoutes(): void;
+    updateLayerVisibility(layer: string, visible: boolean): void;
+    getCenterCoordinates(): FloorPlanGetCoordsEvent;
+    exhibitorsList(): FloorPlanExhibitor[];
+    boothsList(): FloorPlanBooth[];
+    categoriesList(): FloorPlanCategory[];
+    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;
+    applyParameters(queryRaw: string): void;
+    getVisibility(): Visibility;
+    setVisibility(visibility: Visibility): void;
+    findLocation(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    switchView(): void;
+    setCamera(camera: Camera): void;
+    getCamera(): Camera;
+    zoomTo(selectors: POISelectors, options?: {
+        padding?: number;
+    }): void;
+    getBounds(selectors: POISelectors): Bounds | undefined;
+    fitBounds(bounds?: Bounds, options?: {
+        padding?: number;
+    }): void;
+    getBoothRect(name: string): BoothRect;
+    convertToGeo(x: number, y: number): [number, number] | never;
+    getGeoConfig(): GeoConfig | null;
+    /**
+     * What this instance owns of the teardown — its React root and the store's
+     * window listeners — run by `FloorPlanLoader.destroy()` while the store
+     * barrel is still live. Everything the plan's services own (URL sync, UI
+     * handlers, GA, telemetry, reactions, timers) registered itself with the
+     * plan when it started, and `disposePlan()` — and with it the dead window —
+     * follows this.
+     */
+    protected releaseResources(): void;
+    search(term: string): Promise<{
+        item: unknown;
+        score: number;
+    }[]>;
+    getFloors(): Floor[];
+    getVenues(): Venue[];
+    getVenueDiagnostics(): VenueDiagnostic[];
+    activateVenue(venueId: {
+        id: string;
+    }): void;
+    activateFloor(floorId: {
+        name?: string;
+        index?: number;
+    }): void;
+    showPathway(pathwayId: string, externalIds: 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;
+}
+/**
+ * Backward-compatible return shape of the public `getBoothRect()` API.
+ *
+ * Internally booth footprints are now `@expofp/geometry` `Box`es, but external
+ * SDK consumers of `getBoothRect()` rely on the legacy `core/Rect` instance
+ * surface (`x1/y1/x2/y2`, the `cx/cy/w/h` getters, and the full method set).
+ * This class reproduces that surface exactly and is built from a `Box`'s
+ * `min`/`max` corners at the API boundary. It is intentionally NOT exported, so
+ * no other module can import it — the only way to obtain one is `getBoothRect()`.
+ */
+declare class BoothRect {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    get h(): number;
+    get w(): number;
+    get cx(): number;
+    get cy(): number;
+    constructor(x1: number, y1: number, x2: number, y2: number);
+    static fromBox(box: Box): BoothRect;
+    static fromCxcywh(cx: number, cy: number, w: number, h: number): BoothRect;
+    contains(r: BoothRect): boolean;
+    intersects(r: BoothRect): boolean;
+    getIntersection(r: BoothRect): BoothRect;
+    getRotated90(): BoothRect;
+    normalize(width: number, height: number): BoothRect;
+    withPadding(x: number, y?: number): BoothRect;
+    scale(s: number): BoothRect;
+    getArea(): number;
+    clone(): BoothRect;
+    translate(dx: number, dy: number): this;
+    equals(r: BoothRect): boolean;
+    toString(): string;
+    containsPoint(x: number, y: number): boolean;
+}
+export {};
+//# sourceMappingURL=floorplan.ready.d.ts.map