@mapvx/web-kit 0.0.0-stage → 1.2.0-develop.8

package/dist/types/index.d.ts

@@ -0,0 +1,1771 @@
+import { Configuration } from '@mapvx/web-js';
+import { CSSResult } from 'lit';
+import { InnerFloor } from '@mapvx/web-js';
+import { LatLng } from '@mapvx/web-js';
+import { LitElement } from 'lit';
+import { MapVXSDK } from '@mapvx/web-js';
+import { MVXPlace } from '@mapvx/web-js';
+import { MVXRoute } from '@mapvx/web-js';
+import { PropertyValues } from 'lit';
+import { ReactiveController } from 'lit';
+import { ReactiveControllerHost } from 'lit';
+import { ReactiveElement } from '@lit/reactive-element';
+import { TemplateResult } from 'lit-html';
+
+/**
+ * LocalStorage keys used by the SDK for caching.
+ *
+ * @description These keys are used internally by the SDK to persist cached data, one per cache
+ * type (web-js 4.3.1 `DEFAULT_CACHE_CONFIGS`). Exposed for advanced use cases like manual cache
+ * inspection or cleanup. A unit test writes every type with the SDK's own `CacheManager` and
+ * checks that this list clears them all, so a renamed key fails it.
+ *
+ * @example Checking cache size
+ * ```typescript
+ * import { CACHE_STORAGE_KEYS } from '@mapvx/web-kit';
+ *
+ * let totalSize = 0;
+ * CACHE_STORAGE_KEYS.forEach(key => {
+ *   const data = localStorage.getItem(key);
+ *   if (data) totalSize += data.length;
+ * });
+ * console.log(`Cache size: ${(totalSize / 1024).toFixed(2)} KB`);
+ * ```
+ */
+export declare const CACHE_STORAGE_KEYS: readonly ["mvx_places", "mvx_routes", "mvx_accessible_routes", "mvx_configurations", "mvx_categories", "mvx_vehicles", "mvx_stops", "mvx_subplaces", "mvx_available_places", "mvx_styles"];
+
+/**
+ * Complete cache configuration for the SDK.
+ *
+ * @description Provides comprehensive control over SDK caching behavior.
+ * Use the provided presets ({@link TOTEM_CACHE_CONFIG}, {@link WEB_CACHE_CONFIG})
+ * or create custom configurations with {@link mergeCacheConfig}.
+ *
+ * @example Using a preset directly
+ * ```typescript
+ * import { TOTEM_CACHE_CONFIG } from '@mapvx/web-kit';
+ *
+ * // Pass to component
+ * element.cacheConfig = TOTEM_CACHE_CONFIG;
+ * ```
+ *
+ * @example Creating a custom configuration
+ * ```typescript
+ * const myConfig: CacheConfig = {
+ *   persistent: true,
+ *   maxStorageBytes: 10 * 1024 * 1024, // 10MB
+ *   configs: {
+ *     places: { maxItems: 500, ttlMs: 2 * 60 * 60 * 1000 },
+ *     subPlaces: { maxItems: 200, ttlMs: 60 * 60 * 1000 },
+ *     routes: { maxItems: 100, ttlMs: 15 * 60 * 1000 },
+ *     accessibleRoutes: { maxItems: 100, ttlMs: 15 * 60 * 1000 },
+ *     configurations: { maxItems: 10, ttlMs: 4 * 60 * 60 * 1000 },
+ *     categories: { maxItems: 50, ttlMs: 2 * 60 * 60 * 1000 },
+ *     vehicles: { maxItems: 20, ttlMs: 30 * 60 * 1000 },
+ *     stops: { maxItems: 50, ttlMs: 30 * 60 * 1000 },
+ *   },
+ * };
+ * ```
+ */
+export declare interface CacheConfig {
+    /**
+     * Enables localStorage persistence across browser sessions.
+     * When true, cached data survives page reloads and browser restarts, except for the types
+     * whose {@link CacheTypeConfig.persist} is `false`.
+     * @defaultValue true (in presets)
+     */
+    persistent: boolean;
+    /**
+     * Largest localStorage entry each cache type may write, in UTF-16 code units despite the name:
+     * the SDK compares it with the length of the serialized string, the unit Chrome counts its quota
+     * in (an origin gets about 5.2 M of them). The SDK applies it to every type on its own, not to
+     * their sum, so it does not bound the total the components store. A type that outgrows it stops
+     * being written and keeps its last stored copy.
+     */
+    maxStorageBytes: number;
+    /**
+     * Per-type cache customization.
+     * Each key represents a different data category with independent limits. `availablePlaces` and
+     * `styles` are optional: left out, the SDK's own defaults apply (persisted, 5 and 20 items).
+     */
+    configs: {
+        /** Location/venue information (parent places, POIs) */
+        places: CacheTypeConfig;
+        /** The places inside each venue (stores, services), one list per venue and language */
+        subPlaces: CacheTypeConfig;
+        /** Standard walking route calculations */
+        routes: CacheTypeConfig;
+        /** Accessibility-optimized routes (wheelchair, reduced mobility) */
+        accessibleRoutes: CacheTypeConfig;
+        /** Map styling and system configurations */
+        configurations: CacheTypeConfig;
+        /** Place categorization and taxonomy data */
+        categories: CacheTypeConfig;
+        /** Transport mode information */
+        vehicles: CacheTypeConfig;
+        /** Transit station/stop data */
+        stops: CacheTypeConfig;
+        /** The api key's place list, which the components no longer prefetch */
+        availablePlaces?: CacheTypeConfig;
+        /** Map styles, one per venue, theme and language (about 50 KB each) */
+        styles?: CacheTypeConfig;
+    };
+}
+
+/**
+ * Configuration for a specific cache type.
+ *
+ * @description Defines storage limits and expiration for a single data category.
+ * Each cache type (places, routes, etc.) can have independent configuration.
+ *
+ * @example
+ * ```typescript
+ * const routeCacheConfig: CacheTypeConfig = {
+ *   maxItems: 100,      // Store up to 100 routes
+ *   ttlMs: 15 * 60000   // Expire after 15 minutes
+ * };
+ * ```
+ *
+ * @example Keeping a type out of localStorage
+ * ```typescript
+ * const subPlacesCacheConfig: CacheTypeConfig = {
+ *   maxItems: 100,
+ *   ttlMs: 15 * 60000,
+ *   persist: false      // In memory only, even when `persistent` is on
+ * };
+ * ```
+ */
+export declare interface CacheTypeConfig {
+    /**
+     * Maximum number of entries to store in this cache.
+     * When exceeded, oldest entries are evicted (LRU policy).
+     */
+    maxItems: number;
+    /**
+     * Time-to-live in milliseconds before expiration.
+     * After this time, cached entries are considered stale and will be refetched.
+     */
+    ttlMs: number;
+    /**
+     * Whether this type is written to localStorage when {@link CacheConfig.persistent} is on.
+     * `false` keeps it in memory only: it is fetched again after a reload, but takes none of the
+     * localStorage the host page shares with the components.
+     * @defaultValue true
+     */
+    persist?: boolean;
+}
+
+/**
+ * Clears all SDK cache entries from localStorage.
+ *
+ * @description Removes all cached data stored by the SDK. This forces the SDK
+ * to fetch fresh data on the next request. Safe to call even if localStorage
+ * is unavailable (fails silently).
+ *
+ * @example Clear cache on user logout
+ * ```typescript
+ * import { clearAllCacheStorage } from '@mapvx/web-kit';
+ *
+ * function handleLogout() {
+ *   clearAllCacheStorage();
+ *   // ... other cleanup
+ * }
+ * ```
+ *
+ * @example Add a "clear cache" button for debugging
+ * ```typescript
+ * document.getElementById('clearCache')?.addEventListener('click', () => {
+ *   clearAllCacheStorage();
+ *   alert('Cache cleared. Refresh the page to see fresh data.');
+ * });
+ * ```
+ */
+export declare function clearAllCacheStorage(): void;
+
+/**
+ * Manages all application contexts and provides typed update methods.
+ * Acts as a single source of truth for state management across components.
+ */
+declare class ContextManager {
+    private sdkProvider;
+    private placeProvider;
+    private routeProvider;
+    private uiProvider;
+    /**
+     * Creates a new ContextManager attached to the given host element.
+     * Sets up all context providers with their initial values.
+     *
+     * @param host - The host element that will provide the contexts
+     */
+    constructor(host: ReactiveElement);
+    /**
+     * Updates the SDK context with partial values.
+     * @param updates - Partial SDK context to merge
+     */
+    updateSDK(updates: Partial<SDKContextType>): void;
+    /**
+     * Gets the current SDK context (read-only).
+     */
+    get sdk(): SDKContextType;
+    /**
+     * Updates the place context with partial values.
+     * @param updates - Partial place context to merge
+     */
+    updatePlace(updates: Partial<PlaceContextType>): void;
+    /**
+     * Gets the current place context (read-only).
+     */
+    get place(): PlaceContextType;
+    /**
+     * Updates the route context with partial values.
+     * @param updates - Partial route context to merge
+     */
+    updateRoute(updates: Partial<RouteContextType>): void;
+    /**
+     * Gets the current route context (read-only).
+     */
+    get route(): RouteContextType;
+    /**
+     * Updates the UI context with partial values.
+     * @param updates - Partial UI context to merge
+     */
+    updateUI(updates: Partial<UIContextType>): void;
+    /**
+     * Gets the current UI context (read-only).
+     */
+    get ui(): UIContextType;
+    /**
+     * Resets all contexts to their initial states.
+     * Useful when navigating away or clearing the current session.
+     */
+    reset(): void;
+    /**
+     * Resets navigation-related state while preserving SDK and parent place.
+     * Useful when selecting a new destination.
+     */
+    resetNavigation(): void;
+    /**
+     * Gets a snapshot of all current context values.
+     * Useful for debugging or logging.
+     */
+    getSnapshot(): {
+        sdk: SDKContextType;
+        place: PlaceContextType;
+        route: RouteContextType;
+        ui: UIContextType;
+    };
+}
+
+/**
+ * Default cache configuration (uses WEB preset).
+ *
+ * @description The default configuration applied when no `cacheConfig` is specified.
+ * Uses {@link WEB_CACHE_CONFIG} for broad compatibility with web deployments.
+ *
+ * @see {@link WEB_CACHE_CONFIG} for detailed settings
+ * @see {@link TOTEM_CACHE_CONFIG} for kiosk deployments
+ */
+export declare const DEFAULT_CACHE_CONFIG: CacheConfig;
+
+export declare const DEFAULT_VECTOR_TILES_BASE_URL = "https://tiles.mapvx.com/tiles";
+
+/**
+ * The floor a route endpoint is on, for a place that exists on several floors (an elevator, a
+ * staircase, an entrance shared by two levels).
+ *
+ * Without it the route starts, or ends, on the first floor the place is listed on: an elevator
+ * picked as the origin of someone standing on level 3 would send them from the basement. Both
+ * fields are optional; `floorId` wins over `level` when both are set, as in the SDK's `IdLocation`.
+ */
+declare interface EndpointFloor {
+    /** Id of the floor (`InnerFloor.key`) the endpoint is on. Takes precedence over {@link level}. */
+    floorId?: string;
+    /**
+     * Level number of that floor (`InnerFloor.level`). A level is not the floor's name: a venue can
+     * call level `-2` "Nivel -1", so prefer {@link floorId} when it is known.
+     */
+    level?: number;
+}
+
+/**
+ * Where a floor selector is anchored inside its component: an edge, and where along that edge.
+ * `map-view-with-modal` and `route-view-totems` take the same values through
+ * `floor-selector-position`.
+ */
+declare const FLOOR_SELECTOR_POSITIONS: readonly ["top-left", "top-center", "top-right", "center-left", "center-right", "bottom-left", "bottom-center", "bottom-right"];
+
+/**
+ * Controller for managing floor-related operations.
+ */
+declare class FloorController implements ReactiveController {
+    private host;
+    private contextManager;
+    constructor(host: ReactiveControllerHost, contextManager: ContextManager);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Sets the current floor by ID.
+     * Does nothing if the floor is already selected or doesn't exist.
+     *
+     * @param floorId - The floor key to select
+     * @returns true if floor was changed, false otherwise
+     */
+    setFloor(floorId: string): boolean;
+    /**
+     * Sets the current floor directly.
+     *
+     * @param floor - The floor object to set as current
+     */
+    setFloorDirect(floor: InnerFloor): void;
+    /**
+     * Gets the currently selected floor.
+     */
+    getCurrentFloor(): InnerFloor | undefined;
+    /**
+     * Gets all available floors in the parent place.
+     */
+    getAllFloors(): InnerFloor[];
+    /**
+     * Gets floors that are part of the current route.
+     * Returns all floors if no route is active.
+     */
+    getEnabledFloors(): InnerFloor[];
+    /**
+     * Checks if a floor is enabled (part of the current route or no route active).
+     *
+     * @param floorId - The floor key to check
+     */
+    isFloorEnabled(floorId: string): boolean;
+    /**
+     * Gets the index of the current floor in the floors list.
+     * Returns -1 if no floor is selected.
+     */
+    getCurrentFloorIndex(): number;
+    /**
+     * Moves to the next floor in the list.
+     * Returns false if already on the last floor.
+     */
+    nextFloor(): boolean;
+    /**
+     * Moves to the previous floor in the list.
+     * Returns false if already on the first floor.
+     */
+    previousFloor(): boolean;
+    /**
+     * Gets the floor count.
+     */
+    getFloorCount(): number;
+    /**
+     * Checks if the current floor is the first floor.
+     */
+    isFirstFloor(): boolean;
+    /**
+     * Checks if the current floor is the last floor.
+     */
+    isLastFloor(): boolean;
+}
+
+/** One of {@link FLOOR_SELECTOR_POSITIONS}. */
+export declare type FloorSelectorPosition = (typeof FLOOR_SELECTOR_POSITIONS)[number];
+
+/**
+ * @description Publishes the rendered width and height of `<floor-selector>` on its container as
+ * {@link FLOOR_SELECTOR_INLINE_SIZE_PROPERTY} and {@link FLOOR_SELECTOR_BLOCK_SIZE_PROPERTY}, so the
+ * siblings laid out around the bar can keep clear of it.
+ *
+ * The bar is as wide as the venue's longest floor name, not its CSS `min-width`: the demo venue's
+ * vertical bar is 115px against a min-width of 87px. `route-options` reserves this width for the
+ * compact card, so the card never slides under the bar in a narrow embed (MFE-492). Custom
+ * properties inherit across shadow roots, so setting it on the shared container is enough.
+ *
+ * Both are the selector's border box, which includes the transparent margin it keeps around the
+ * bar for its shadow. Only the one across the bar's edge is published: the width of a vertical bar,
+ * the height of a horizontal one. The other is removed, since it measures the layout rather than
+ * the bar (a vertical bar's host spans the full height): left in place, a bar moved to another edge
+ * would be laid out against it until the next report, rather than against the stylesheets'
+ * fallbacks. `floor-selector.css` lays a vertical bar's host out as a column, which is how the
+ * orientation is told apart. Tracked with a `ResizeObserver`, so they follow floor names, the layout
+ * switch at the container breakpoint, a new `floor-selector-position` and the late definition of
+ * the lazily loaded element. A report of 0px (the element before it is defined and laid out) is not
+ * published: the stylesheets' fallbacks stand in until the first real size. Neither is a report
+ * from a bar without floors, which is a placeholder rather than a bar
+ * ({@link FLOOR_SELECTOR_HAS_FLOORS_ATTRIBUTE}).
+ *
+ * @example
+ * ```ts
+ * // A class field next to the host's other controllers. It is never read, so `protected` rather
+ * // than `private`: `noUnusedLocals` rejects a private field that is only held (TS6133).
+ * protected readonly floorSelectorSize = new FloorSelectorSizeController(this, '.route-container')
+ * ```
+ */
+declare class FloorSelectorSizeController implements ReactiveController {
+    private observer;
+    private readonly host;
+    private readonly containerSelector;
+    /**
+     * @param host Component that renders `<floor-selector>` in its shadow root.
+     * @param containerSelector Selector, in the same shadow root, of the element that receives the
+     * custom property: the common ancestor of the bar and the elements that keep clear of it.
+     */
+    constructor(host: ReactiveControllerHost & HTMLElement, containerSelector: string);
+    /** Resumes observing when an already rendered host is attached again. */
+    hostConnected(): void;
+    /** Starts observing once the first render has put the selector in the shadow root. */
+    hostUpdated(): void;
+    hostDisconnected(): void;
+    private observe;
+}
+
+export declare class MapViewWithModal extends LitElement {
+    static styles: CSSResult[];
+    apiKey: string;
+    parentPlaceId: string;
+    locale: string;
+    /**
+     * Enables the experimental 3D scene on the underlying map (forwarded to `<custom-map>`).
+     *
+     * **Off by default**, unlike `<route-view-totems>`. This view is the one embedded in public web
+     * and mobile pages, where the extra WebGL cost is rarely wanted and the 3D overlay has no label
+     * collision detection, so 3D is something the page opts into rather than inherits.
+     *
+     * Turning it on is still not sufficient: the parent place must also be in `scene-3d-place-ids`, and
+     * the API key's style must publish `fill-extrusion` layers.
+     */
+    enable3D: boolean;
+    /**
+     * Parent places the 3D scene is allowed on, as a comma-separated list of ids (forwarded to
+     * `<custom-map>`). Empty (the default) keeps `<custom-map>`'s own validated default set.
+     */
+    scene3dPlaceIds: string[];
+    /**
+     * Destination popup style (forwarded to `<custom-map>`): `full` shows logo + name + category,
+     * `compact` shows a small icon-only bubble. Defaults to `compact`; pass `full` to opt back in.
+     */
+    markerVariant: string;
+    /** The one place shown on the map, as a destination marker (no route, no origin). */
+    placeId: string;
+    /** Institution identifier forwarded to MapVX API as the `X-MapVx-Institution-Id` request header. */
+    institutionId: string;
+    /** Human-readable institution name forwarded to MapVX API as the `X-MapVx-Institution-Name` request header. */
+    institutionName: string;
+    /** Forwarded to `<custom-map>` and reflected on this host too, for its own compact-mode CSS. */
+    compactMode: boolean;
+    /** `'small' | 'normal' | 'large'`. Forwarded to `<custom-map>` and reflected on this host too. */
+    zoomButtonSize: string;
+    /** Maximum zoom cap used when fitting markers in the map-with-modal view. */
+    fitMaxZoom: number;
+    /** Maximum zoom cap used when focusing a single point in the map-with-modal view. */
+    singlePointMaxZoom: number;
+    /** Maximum zoom cap used when fitting route geometry in the map-with-modal view. */
+    routeFitMaxZoom: number;
+    /** Base camera padding for the top edge in the map-with-modal view. */
+    cameraPaddingTop: number;
+    /** Base camera padding for the right edge in the map-with-modal view. */
+    cameraPaddingRight: number;
+    /** Base camera padding for the bottom edge in the map-with-modal view. */
+    cameraPaddingBottom: number;
+    /** Base camera padding for the left edge in the map-with-modal view. */
+    cameraPaddingLeft: number;
+    /**
+     * Overlay padding strategy used by the map-with-modal view: `none`, `auto` or `left-panel-stack`.
+     * `free-space` (MFE-523) is for `<route-view-totems>` only: this view does not measure the compact
+     * floor selector it renders.
+     */
+    overlayPaddingMode: string;
+    /**
+     * Cache configuration for SDK data. Defaults to {@link WEB_CACHE_CONFIG}, the preset built for this
+     * component's web/mobile deployment. What is set here is merged **over that preset**, so a partial
+     * override changes only the entries it names.
+     */
+    cacheConfig: CacheConfig | undefined;
+    /** {@link cacheConfig} resolved against the web preset it defaults to. */
+    private get _effectiveCacheConfig();
+    /**
+     * Whether the compact floor selector is rendered. **On by default**, so the attribute value is
+     * what turns it off: `show-floor-selector="false"` (see {@link defaultTrueBooleanConverter}). The
+     * lowercase spelling `showfloorselector` is still accepted as a legacy alias.
+     */
+    showFloorSelector: boolean;
+    /**
+     * Corner or edge the floor selector is anchored to, trimmed and lowercased first. The lowercase
+     * `floorselectorposition` is still accepted as a legacy alias.
+     */
+    floorSelectorPosition: string;
+    /**
+     * Renders the floor selector but blocks floor changes. Off by default; present disables, absent or
+     * `floor-selector-disabled="false"` enables (see {@link defaultFalseBooleanConverter}). The
+     * lowercase `floorselectordisabled` is still accepted as a legacy alias.
+     */
+    floorSelectorDisabled: boolean;
+    /**
+     * Hides the built-in loading indicator so the host can show its own. Reads the attribute's value
+     * rather than its presence (see {@link defaultFalseBooleanConverter}), so `hide-loading="false"`
+     * keeps the indicator.
+     */
+    hideLoading: boolean;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, oldValue: string | null, value: string | null): void;
+    /* Excluded from this release type: contextManager */
+    /* Excluded from this release type: placeController */
+    /* Excluded from this release type: routeController */
+    /* Excluded from this release type: floorController */
+    constructor();
+    /** The inner `custom-map`. Always rendered (no lazy loading yet; see Task 11's own scope). */
+    private _customMap;
+    /** The inner `compact-floor-selector`, or `null` while {@link showFloorSelector} is off. */
+    private _compactFloorSelector;
+    /** Context forwarded to MapVX API as `X-MapVx-*` and `mvx-product` request headers. */
+    private mapVxRequestContext;
+    private readonly analyticsController;
+    /**
+     * The tiles service worker, run exactly as the reference's own `_initTileServiceWorker()`/
+     * `_syncTilePrefetch()` do: registered and asked for the initial tile prefetch from
+     * `firstUpdated()`, asked again when `apiKey`/`parentPlaceId` change, the periodic refresh
+     * (production builds only) stopped on disconnect. See {@link TileServiceWorkerController}.
+     */
+    private readonly tileServiceWorker;
+    firstUpdated(): void;
+    /** Same shape as the reference's own `baseParams()`: no route, so no destination/origin fields. */
+    private baseParams;
+    private _mapReadyHandler;
+    private _cameraInitializedHandler;
+    /**
+     * The floor id this handler last reported `floor_change` analytics for — this element's own
+     * dedupe, independent of `FloorController.setFloor()`'s return value (review round 1, finding 1).
+     *
+     * An earlier version gated the analytics call on `setFloor()`'s own return (`true` only when it
+     * actually changed `uiContext.currentFloor`), reasoning that was a more reliable dedupe than a
+     * locally-tracked field. That reasoning held for `<custom-map>`'s own `floorChange` (it never
+     * touches `FloorController` itself before dispatching), but broke for
+     * `<compact-floor-selector>`'s: `BaseFloorSelector.selectFloor()` (Task 3) already calls
+     * `floorController.setFloor(floorKey)` ITSELF before dispatching the event, so by the time this
+     * handler ran, the change had already been applied and `setFloor()` correctly (but unhelpfully,
+     * for that gate) returned `false` for every single selector click — analytics never fired at all.
+     * Verified with a real click on `.floor-option` (not a mocked `setFloor`) in this file's own test
+     * suite. Tracking the last-notified id here, instead of trusting the controller's own return value,
+     * works the same for both event sources regardless of which of them already consumed the change.
+     */
+    private _lastNotifiedFloorId;
+    /**
+     * Turns `<custom-map>`'s/`<compact-floor-selector>`'s `floorChange` event into
+     * `FloorController.setFloor()`, closing the loop for a floor change that originated on the map SDK
+     * side rather than through the controller (see Task 9's identical wiring and its own doc comment).
+     * Safe to call for either source: idempotent on an already-applied floor.
+     */
+    private _floorChangeHandler;
+    updated(changedProperties: PropertyValues): void;
+    /** The `placeId` last passed to {@link PlaceController.setOriginAndDestination}, or `undefined`. */
+    private _placeIdRequestedFor;
+    /**
+     * Loads {@link placeId} through `PlaceController` once an SDK is actually available for it. No
+     * origin and no route: the single place is loaded as the "destination" so `PlaceController`
+     * marks and frames it the same way it would a route's destination.
+     *
+     * Dedupes on the value it last actually requested, independent of whether `placeId` happened to
+     * be in `changedProperties` for the update pass this runs in — see `updated()`'s own call site for
+     * why that matters (review round 1, finding 2). Checking the SDK's own readiness itself, rather
+     * than only relying on `PlaceController.setOriginAndDestination()`'s internal no-op when the SDK
+     * isn't ready yet, matters here specifically: without it, a call made before the SDK exists would
+     * still mark `placeId` as "already requested" and this method would never retry it once the SDK
+     * actually becomes available.
+     */
+    private maybeLoadPlace;
+    private getFloorSelectorPositionStyles;
+    render(): TemplateResult<1>;
+    /**
+     * Destroys the map and builds a fresh one, keeping venue, place and markers. Not needed on
+     * unmount: the map (and its WebGL context) is released automatically when the element leaves the
+     * page. A no-op until `<custom-map>` has built one.
+     * @example
+     * ```ts
+     * document.querySelector('map-view-with-modal')?.reloadMap();
+     * ```
+     */
+    reloadMap(): void;
+}
+
+declare interface MarkerContext {
+    style: MarkerStyle;
+    id: string;
+    data: MVXPlace | PlacePopupData;
+    /**
+     * Floor the marker is drawn on, when it is not the place's first floor: a route endpoint on a
+     * place that spans several floors (an elevator) is drawn on the floor the route starts or ends.
+     */
+    floorId?: string;
+}
+
+/**
+ * Marker visual style.
+ *
+ * Written as a frozen object + derived union rather than a TS `enum`: this project's tsconfig sets
+ * `erasableSyntaxOnly`, which disallows `enum` declarations because they emit non-erasable runtime
+ * code. Call sites are unchanged from the reference — `MarkerStyle.youAreHere` still works, and the
+ * type `MarkerStyle` still names the union of valid values.
+ */
+declare const MarkerStyle: {
+    readonly youAreHere: "youAreHere";
+    readonly placePopup: "placePopup";
+    readonly pin: "pin";
+    readonly default: "default";
+};
+
+declare type MarkerStyle = (typeof MarkerStyle)[keyof typeof MarkerStyle];
+
+/**
+ * Merges a partial cache configuration with a base configuration.
+ *
+ * @description Merges per cache type: the types an override names replace the base's entries
+ * whole, and the rest keep the base's. This is the recommended way to customize cache behavior.
+ *
+ * Because an entry is replaced whole, `persist` included, overriding `subPlaces` over
+ * {@link WEB_CACHE_CONFIG} without `persist: false` persists them. The SDK controller relies on
+ * it: it merges the totem preset over the web default, and the totem's `subPlaces` must not pick
+ * up the web's `persist: false`.
+ *
+ * @param base - The base configuration to start from (e.g., TOTEM_CACHE_CONFIG)
+ * @param overrides - Partial configuration with values to override
+ * @returns Complete cache configuration with overrides applied
+ *
+ * @example Override storage limit only
+ * ```typescript
+ * const config = mergeCacheConfig(WEB_CACHE_CONFIG, {
+ *   maxStorageBytes: 8 * 1024 * 1024, // 8MB instead of 5MB
+ * });
+ * ```
+ *
+ * @example Override specific cache type
+ * ```typescript
+ * const config = mergeCacheConfig(TOTEM_CACHE_CONFIG, {
+ *   configs: {
+ *     routes: { maxItems: 200, ttlMs: 30 * 60 * 1000 } // Longer route cache
+ *   }
+ * });
+ * ```
+ *
+ * @example Multiple overrides
+ * ```typescript
+ * const config = mergeCacheConfig(WEB_CACHE_CONFIG, {
+ *   persistent: false, // Disable persistence
+ *   maxStorageBytes: 2 * 1024 * 1024, // Reduce to 2MB
+ *   configs: {
+ *     places: { maxItems: 50, ttlMs: 10 * 60 * 1000 }, // Smaller, shorter
+ *     routes: { maxItems: 25, ttlMs: 2 * 60 * 1000 },  // Very short TTL
+ *   }
+ * });
+ * ```
+ */
+export declare function mergeCacheConfig(base: CacheConfig, overrides?: Partial<CacheConfig>): CacheConfig;
+
+/** Name of the event this component dispatches on a map failure. */
+export declare const MVX_ERROR_EVENT = "mvxError";
+
+/**
+ * Helpers for the MapVX tiles service worker shipped at `/mvx-tiles-sw.js`.
+ * Host apps must serve that file at the site root (HTTPS).
+ *
+ * Ported verbatim from `web-components/src/utils/mvx-tile-sw.ts` — no client-specific behavior to
+ * adapt and no Sentry usage to swap out (the Global Constraint against a global `Sentry.init()`
+ * does not apply here: this file never reports errors at all, let alone through the global client).
+ *
+ * Only the registration/messaging helpers below are ported. The reference's actual worker script
+ * (`web-components/src/sw/mvx-tiles-sw.js`, copied to `dist/sw/` by its own build step) is a
+ * separate ~570-line runtime asset, not a "util", and is out of this task's scope; a host integrator
+ * must still supply their own tiles service worker file at the path these helpers register.
+ */
+export declare const MVX_TILES_SW_PATH = "/mvx-tiles-sw.js";
+
+export declare const MVX_TILES_SW_SCOPE = "/";
+
+/** Reasons `<custom-map>` dispatches its `mvxError` event for. Narrower than the reference's
+ * `MvxErrorCode`: only the map-rebuild case is reported. web-kit's `PlaceController`/
+ * `RouteController` do not produce the reference's place/route loading-failure codes (see
+ * `docs/parity-checklist.md`'s "Known gaps"). */
+export declare type MvxErrorCode = 'MAP_CONTEXT_LOST';
+
+/** Payload of the `mvxError` event, ported (narrowed) from the reference's `models/mvx-error.ts`. */
+export declare interface MvxErrorDetail {
+    code: MvxErrorCode;
+    message: string;
+    parentPlaceId?: string;
+}
+
+/**
+ * Detail of the `mvxLoadingChange` event, ported verbatim from the reference's
+ * `models/loading-events.ts`.
+ */
+export declare interface MvxLoadingChangeDetail {
+    /** Whether a loading indicator should be on screen right now. */
+    loading: boolean;
+    /**
+     * What is being waited on:
+     * - `places` — resolving the origin and destination.
+     * - `route` — generating the route between them.
+     * - `camera` — the map is settling on what it has to show: framing the pair or the route it just
+     *   received, building itself on a cold start, or clearing itself for the next destination. The
+     *   catch-all for "the data is in, the map is not ready to be looked at yet".
+     * - `idle` — nothing; emitted with `loading: false` when the load ends.
+     */
+    phase: 'places' | 'route' | 'camera' | 'idle';
+}
+
+export declare interface MvxTilePrefetchOptions {
+    apiKey: string;
+    placeId: string;
+    tilesBaseUrl?: string;
+}
+
+/**
+ * The floors asked for the two ends of a route. Same shape as the reference's `PairFloors`
+ * (`sdk-controller.ts`): `undefined` means "not given", `{}` means "given as no floor".
+ */
+declare interface PairFloors {
+    originFloor?: EndpointFloor;
+    destinationFloor?: EndpointFloor;
+}
+
+/**
+ * Context type for place-related state.
+ */
+declare interface PlaceContextType {
+    /** Parent place containing floors and configuration */
+    parentPlace?: MVXPlace;
+    /** Origin place for navigation */
+    origin?: MVXPlace;
+    /** Destination place for navigation */
+    destination?: MVXPlace;
+    /** Origin place ID */
+    originId?: string;
+    /** Destination place ID */
+    destinationId?: string;
+    /** General configuration for the parent place */
+    generalConfig?: Configuration;
+    /**
+     * Floor of the origin, for an origin on several floors (an elevator). See {@link EndpointFloor}.
+     * Matches the reference's (legacy, flat) `sdkContext` field of the same name. Written by
+     * `PlaceController.setOriginAndDestination` with the pair it loads; read by `route-options` (the
+     * floor shown next to the origin row) and by `RouteController` (the floor the route starts on).
+     */
+    originFloor?: EndpointFloor;
+    /** Floor of the destination, for a destination on several floors. Same notes as {@link originFloor}. */
+    destinationFloor?: EndpointFloor;
+    /**
+     * Whether the origin/destination places are currently being fetched — the `places` phase of
+     * `<custom-map>`'s loading overlay and `mvxLoadingChange`. Matches the reference's (legacy, flat)
+     * `sdkContext.isLoading`. Raised by `PlaceController.setOriginAndDestination` before the fetch and
+     * cleared once it settles (success or failure); not raised by the parent-place load, as in the
+     * reference.
+     */
+    isLoading?: boolean;
+}
+
+/**
+ * Controller for managing place-related operations.
+ */
+declare class PlaceController implements ReactiveController {
+    private host;
+    private contextManager;
+    private connected;
+    /**
+     * Request counter, the reference's `placesRequest`. Every pair load bumps it and keeps the value it
+     * started with; its answer is written only if the counter has not moved since. Comparing ids is not
+     * enough: the same pair can be requested twice, and an older request for another pair can land
+     * after a newer one. {@link reset} bumps it too, so a load still in flight when the kiosk is reset
+     * for the next visitor never writes its places back.
+     */
+    private placesRequest;
+    /**
+     * The venue load in flight, if any. A pair whose floor is asked for by level waits for it before
+     * publishing: only the venue's floors say which floor a level is (the reference's `venueLoad`).
+     */
+    private venueLoad;
+    constructor(host: ReactiveControllerHost, contextManager: ContextManager);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Loads the parent place and its configuration.
+     *
+     * Does not raise `placeContext.isLoading`: the reference's venue load (`prewarm`/`initializeSDK`)
+     * does not either — that flag is the `places` loading phase of an origin/destination load only.
+     *
+     * The venue can land after the pair on screen (both start in the same update on a cold start).
+     * When it does, the pair's floor is shown rather than the venue's first floor, and its markers and
+     * enabled floors are rebuilt — only the venue's floors can resolve a floor asked for by level. The
+     * reference's `publishVenue`.
+     *
+     * @param parentPlaceId - The ID of the parent place to load
+     * @returns The loaded parent place or undefined on error
+     */
+    loadParentPlace(parentPlaceId: string): Promise<MVXPlace | undefined>;
+    /** The body of {@link loadParentPlace}, split out so a pair load can wait on it. */
+    private fetchParentPlace;
+    /**
+     * Sets the origin and destination places.
+     * Fetches place details and updates markers.
+     *
+     * Raises `placeContext.isLoading` before the fetch and clears it once the fetch settles, on
+     * success and on failure alike — the `places` phase of `<custom-map>`'s loading overlay and
+     * `mvxLoadingChange`. A load superseded by a newer one (or by {@link reset}) writes nothing and
+     * leaves the flag to the load that superseded it.
+     *
+     * @param originId - The ID of the origin place
+     * @param destinationId - The ID of the destination place
+     * @param floors - Floors asked for each end (`origin-floor-id`/`origin-level` and their destination
+     *   twins). An end left `undefined` keeps the floor already set when it is the same place, and
+     *   drops it otherwise — the reference's `floorsFor`; `{}` says "no floor".
+     * @returns `true` once this load's places are in context and every requested place resolved;
+     *   `false` when it was superseded, could not run (disconnected, no SDK), or a place failed to
+     *   load. A route asked for alongside this load uses it as its gate (see
+     *   `RouteController.generateRoute`'s `after` option).
+     */
+    setOriginAndDestination(originId: string, destinationId: string, floors?: PairFloors): Promise<boolean>;
+    /**
+     * Writes the places a load resolved, with their markers, the floor to show and the floors the
+     * selector offers, and ends the `places` phase. The reference's `publishPlaces`.
+     */
+    private publishPlaces;
+    /**
+     * The floors of a pair about to load: the ones given, else the ones already set. A floor belongs
+     * to the place it was given for: kept for a reload of the same place, never carried over to
+     * another place, where it would name a floor that place may not even be on. The reference's
+     * `floorsFor`.
+     */
+    private floorsFor;
+    /** The venue's floors: the parent place's, else whatever the floor selector was given. */
+    private venueFloors;
+    /**
+     * Creates markers for origin and destination, each on the floor its end of the route is on
+     * ({@link endpointFloorId}: the floor asked for when the place is on it, else its first floor).
+     */
+    private updateMarkers;
+    /**
+     * Opens the floor the map shows for the pair: the destination's (the floor asked for it, when the
+     * place is on it), else the origin's — {@link shownFloorId}, the same rule the reference's
+     * `publishPlaces` selects with. A pair with no resolvable floor keeps the floor already shown.
+     */
+    private updateCurrentFloor;
+    /**
+     * Updates enabled floors to the floor each end of the route is on. Left alone while a route is on
+     * screen: the route enables every floor it passes through, the richer set (the reference's
+     * `routeOwnsFloors`). An empty list means "no endpoint floor", which the floor selector reads as
+     * "every floor".
+     */
+    private updateEnabledFloors;
+    /**
+     * Gets the current destination place.
+     */
+    getDestination(): MVXPlace | undefined;
+    /**
+     * Gets the current origin place.
+     */
+    getOrigin(): MVXPlace | undefined;
+    /**
+     * Resets the pair for the next visitor: origin, destination, their ids and floors, the markers,
+     * the `places` phase, and the view the last pair left — the camera (so `<qr-modal>`, which shows
+     * only once the camera is initialized, hides again) and the floor (back to the venue's first). The
+     * place half of the reference's `resetData()`; also drops any load still in flight.
+     */
+    reset(): void;
+}
+
+/**
+ * Plain-object marker payload, used when the caller renders a popup marker without a full
+ * {@link MVXPlace} (e.g. a destination reconstructed from host attributes). Every field is optional
+ * because callers outside this package build these objects by hand.
+ */
+declare interface PlacePopupData {
+    name?: string;
+    category?: string;
+    logo?: string;
+    position?: LatLng;
+    floorId?: string;
+}
+
+/**
+ * Visual variant of the place popup marker.
+ *
+ * - `compact`: icon only, in a small bubble anchored above the point. Default, since the place name
+ *   is usually already visible elsewhere in the UI (e.g. the modal) and the big bubble covers the map.
+ * - `full`: logo + name + category, the historical look. Opt-in via `marker-variant="full"`.
+ */
+export declare type PopupVariant = 'full' | 'compact';
+
+/**
+ * Registers the tiles service worker and starts bounded prefetch in one call.
+ *
+ * @description Pairs registration with the wait and the initial load, so a caller does not have to
+ * know that messaging a worker before it is active is dropped silently. Everything is best-effort:
+ * a worker that cannot be registered yields a `null` registration, and the prefetch calls then do
+ * nothing rather than throwing.
+ *
+ * The periodic refresh re-reads `options` on every tick, so later changes to `apiKey` and
+ * `placeId` are picked up. `import.meta.env.PROD` is resolved when this package is built, not when
+ * the host is, so in the published bundles the refresh is scheduled whenever
+ * `enablePeriodicRefresh` is set — a development build of the host does not turn it off.
+ * @param options - Prefetch credentials, plus the worker's path and scope and whether to keep
+ * refreshing
+ * @returns The registration, and a function that stops the periodic refresh (a no-op when none was
+ * scheduled)
+ * @example
+ * const { registration, stopPeriodicRefresh } = await registerAndTriggerTilePrefetch({
+ *   apiKey: 'key',
+ *   placeId: 'place',
+ *   enablePeriodicRefresh: true,
+ * });
+ * // call stopPeriodicRefresh() when tearing the view down
+ */
+export declare function registerAndTriggerTilePrefetch(options: MvxTilePrefetchOptions & {
+    swPath?: string;
+    swScope?: string;
+    enablePeriodicRefresh?: boolean;
+}): Promise<{
+    registration: ServiceWorkerRegistration | null;
+    stopPeriodicRefresh: () => void;
+}>;
+
+/**
+ * Registers the MapVX tiles service worker.
+ *
+ * @description Best-effort: returns `null` instead of throwing when the browser has no service
+ * worker support, when there is no `navigator` at all (SSR), or when `register` rejects because
+ * the host does not serve the file, serves it with the wrong MIME type, or blocks it by CSP.
+ * @param swPath - Path the worker is served from
+ * @param scope - Scope the worker controls
+ * @returns The registration, or `null` when the worker could not be registered
+ * @example
+ * const registration = await registerMvxTileServiceWorker();
+ * if (registration) {
+ *   await waitForServiceWorkerReady(registration);
+ * }
+ */
+export declare function registerMvxTileServiceWorker(swPath?: string, scope?: string): Promise<ServiceWorkerRegistration | null>;
+
+/**
+ * Context type for route-related state.
+ */
+declare interface RouteContextType {
+    /** Current route being displayed/animated */
+    route?: MVXRoute;
+    /** Whether to prefer accessible routes */
+    accessibleRoute: boolean;
+    /** Whether route animation is currently playing */
+    isAnimating: boolean;
+    /** Whether a route is currently being loaded. `RouteController` keeps it in step with {@link loadingRoute}. */
+    isLoading: boolean;
+    /** Floors that are part of the current route */
+    enabledFloors: InnerFloor[];
+    /**
+     * Whether a route is currently being generated — the `route` phase of `<custom-map>`'s loading
+     * overlay and `mvxLoadingChange`, and what `route-options` reads to keep its panel busy. Matches
+     * the reference's (legacy, flat) `sdkContext` field of the same name (the places' own loading flag
+     * is `placeContext.isLoading`). Raised by `RouteController` for the whole time a route is being
+     * asked for — from the moment it is requested alongside a pair's places — and cleared once the
+     * request settles, or is dropped by `clearRoute()`.
+     */
+    loadingRoute?: boolean;
+    /**
+     * Error message from the last failed route generation attempt, surfaced by `route-options`'s
+     * error modal. Matches the reference's (legacy, flat) `sdkContext` field of the same name. No
+     * web-kit controller produces it from a real failure yet (see `docs/parity-checklist.md`'s "Known
+     * gaps"); `RouteController.reset()` and the `dismissRouteError` handler clear it.
+     */
+    routeError?: string;
+    /** Whether {@link routeError} was caused by a network failure (a different icon is shown for it). */
+    isNetworkError?: boolean;
+    /** Set when the last route request failed; stays set after the error modal is dismissed. */
+    routeFailed?: boolean;
+    /** Set when origin or destination failed to load; stays set after the error modal is dismissed. */
+    placesFailed?: boolean;
+}
+
+/**
+ * Controller for managing route-related operations.
+ */
+declare class RouteController implements ReactiveController {
+    private host;
+    private contextManager;
+    private connected;
+    /**
+     * Request counter, the reference's `routeRequest`. Every route request bumps it and keeps the value
+     * it started with; its answer is written only if the counter has not moved since — last request
+     * wins (a second switch toggle, a new pair). {@link clearRoute} bumps it too: a route dropped
+     * because the pair was replaced or the kiosk was reset must not come back when its answer lands.
+     */
+    private routeRequest;
+    constructor(host: ReactiveControllerHost, contextManager: ContextManager);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Loads a route between two places.
+     *
+     * Raises `routeContext.loadingRoute` (and `isLoading`, kept in step with it) before the request
+     * and clears it once the request settles, on every path this request still owns. A request
+     * superseded by a newer one, or by {@link clearRoute}, writes nothing.
+     *
+     * @param originId - The origin place ID
+     * @param destinationId - The destination place ID
+     * @param preferAccessible - Whether to prefer accessible routes
+     * @param floors - Floors of each end; defaults to the ones set for the pair on screen
+     *   (`placeContext.originFloor`/`destinationFloor`)
+     * @returns The loaded route or undefined on error
+     */
+    loadRoute(originId: string, destinationId: string, preferAccessible?: boolean, floors?: PairFloors): Promise<MVXRoute | undefined>;
+    /** The body of a route request once its token is taken and the `route` phase is raised. */
+    private requestRoute;
+    /** Raises or ends the `route` phase. `isLoading` is kept in step with `loadingRoute`. */
+    private setLoading;
+    /** The floors set for the pair on screen. */
+    private pairFloors;
+    /** The location of one end of the route, with its floor resolved against what is loaded. */
+    private endpointLocation;
+    /**
+     * Whether the pair a route was asked for is still the one on screen. A context with no pair at
+     * all (a route asked for directly, outside any pair load) accepts any route.
+     */
+    private isPairOnScreen;
+    /**
+     * Extracts unique floors from a route's steps.
+     */
+    private extractFloorsFromRoute;
+    /**
+     * Generates a route using current origin and destination.
+     *
+     * @param options.after - The pair load this route follows (`PlaceController
+     *   .setOriginAndDestination`'s promise). The `route` phase is raised at once, so the loading
+     *   overlay goes straight from `places` to `route` without ever reading as idle in between; the
+     *   request itself goes out only once that load resolves `true`, reading the pair, its floors and
+     *   the route type from context then — so a level is sent against the loaded place, and a switch
+     *   toggled while the places load is honoured. Resolving `false` (the places failed, or a newer
+     *   load superseded it) asks for nothing, the reference's `publishAfter` gate.
+     */
+    generateRoute(options?: {
+        after?: Promise<boolean>;
+    }): Promise<MVXRoute | undefined>;
+    /**
+     * Sets the accessible route preference and reloads route if one exists.
+     *
+     * @param accessible - Whether to prefer accessible routes
+     */
+    setAccessibleRoute(accessible: boolean): Promise<void>;
+    /**
+     * Starts the route animation.
+     */
+    startAnimation(): void;
+    /**
+     * Stops the route animation.
+     */
+    stopAnimation(): void;
+    /**
+     * Repeats the route animation from the beginning.
+     */
+    repeatAnimation(): void;
+    /**
+     * Clears the current route.
+     *
+     * By default also drops any request still in flight (its answer would otherwise land on whatever
+     * pair replaced it) and ends the `route` phase — what the reference's `SDKController` does on every
+     * pair replacement and on `resetData()`.
+     *
+     * @param options.keepInFlight - Only take the route off the screen, leaving a request in flight
+     *   (and its `route` phase) alone. For `<custom-map>`'s passive destination-change detection: by
+     *   the time it notices the new destination, whatever replaced the pair has already superseded any
+     *   stale request, and the one in flight is the new pair's own.
+     */
+    clearRoute(options?: {
+        keepInFlight?: boolean;
+    }): void;
+    /**
+     * Resets everything route-related for the next visitor: the route and any request in flight
+     * ({@link clearRoute}), the floors the route enabled, the last request's error state, and the route
+     * type — back to `defaultAccessibleRoute`, what the host configured (`accessible-route`), not to
+     * whatever the last visitor's switch left. The route half of the reference's `resetData()`.
+     *
+     * @param defaultAccessibleRoute - The host's configured route type
+     */
+    reset(defaultAccessibleRoute: boolean): void;
+    /**
+     * Gets the current route.
+     */
+    getRoute(): MVXRoute | undefined;
+    /**
+     * Checks if a route is currently loaded.
+     */
+    hasRoute(): boolean;
+    /**
+     * Checks if a route is currently being loaded.
+     */
+    isLoading(): boolean;
+    /**
+     * Checks if a route animation is currently playing.
+     */
+    isAnimating(): boolean;
+    /**
+     * Clears the SDK routes cache.
+     */
+    clearCache(): void;
+}
+
+/**
+ * Layout of the route panel rendered by `<route-options>`.
+ *
+ * - `full`: back bar, destination name, floor and distance, origin/destination rows, accessible
+ *   route switch, "Repetir ruta" and "Generar ruta". Default.
+ * - `compact`: a single card with the destination name, floor and distance, and the accessible
+ *   route switch beside them. No back bar, no origin/destination rows, no "Repetir ruta".
+ */
+export declare type RoutePanelVariant = 'full' | 'compact';
+
+export declare class RouteViewTotems extends LitElement {
+    static styles: CSSResult[];
+    apiKey: string;
+    parentPlaceId: string;
+    /**
+     * Enables the experimental 3D scene on the underlying map (forwarded to `<custom-map>`).
+     *
+     * **On by default**, because it is not the only condition: the scene also requires the parent
+     * place to be in `scene-3d-place-ids`, so an integration that says nothing gets 3D on the venues
+     * the scene was built for and plain 2D everywhere else.
+     *
+     * Set `enable-3d="false"` to force 2D on a venue that is in the list.
+     */
+    enable3D: boolean;
+    /**
+     * Parent places the 3D scene is allowed on, as a comma-separated list of ids (forwarded to
+     * `<custom-map>`). Empty (the default) keeps `<custom-map>`'s own validated default set.
+     */
+    scene3dPlaceIds: string[];
+    /**
+     * Destination popup style (forwarded to `<custom-map>`): `full` shows logo + name + category,
+     * `compact` shows a small icon-only bubble. Defaults to `compact`; pass `full` to opt back in.
+     */
+    markerVariant: string;
+    locale: string;
+    originId: string;
+    /** Institution identifier forwarded to MapVX API as the `X-MapVx-Institution-Id` request header. */
+    institutionId: string;
+    /** Human-readable institution name forwarded to MapVX API as the `X-MapVx-Institution-Name` request header. */
+    institutionName: string;
+    /** Maximum zoom cap used when fitting origin and destination in the totem view. */
+    fitMaxZoom: number;
+    /** Maximum zoom cap used when focusing a single point in the totem view. */
+    singlePointMaxZoom: number;
+    /** Maximum zoom cap used when fitting route geometry in the totem view. */
+    routeFitMaxZoom: number;
+    /** Base camera padding for the top edge in the totem view. */
+    cameraPaddingTop: number;
+    /** Base camera padding for the right edge in the totem view. */
+    cameraPaddingRight: number;
+    /** Base camera padding for the bottom edge in the totem view. */
+    cameraPaddingBottom: number;
+    /**
+     * Base camera padding for the left edge in the totem view. The overlays (route panel, QR card,
+     * floor bar, zoom buttons) are measured on top of it inside `<custom-map>`, as `overlay-padding-mode` says.
+     */
+    cameraPaddingLeft: number;
+    /**
+     * How the camera keeps the route clear of what is drawn over the map: `free-space` (default)
+     * measures every overlay at each fit and frames the route in the free rect where it is drawn
+     * largest; `left-panel-stack` reserves the panel's width over the full height; `auto` adds top
+     * padding under the panel; `none` uses only `camera-padding-*`. Forwarded to `<custom-map>`.
+     */
+    overlayPaddingMode: string;
+    /** Hides the "Volver" bar rendered on top of the route panel. */
+    hideBack: boolean;
+    /**
+     * Hides the built-in loading indicator so the host can show its own. Reads the attribute's value
+     * rather than its presence (see {@link defaultFalseBooleanConverter}), so `hide-loading="false"`
+     * keeps the indicator.
+     */
+    hideLoading: boolean;
+    /** Hides the "Repetir ruta" button shown next to the destination name once a route has been generated. */
+    hideRepeatRoute: boolean;
+    /** Hides the origin/destination rows of the route panel. Destination name, floor, distance and the accessible-route switch stay visible. */
+    hideRouteInputs: boolean;
+    /** Hides the walking / accessible route switch. Routes are then always walking routes. */
+    hideAccessibilitySwitch: boolean;
+    /**
+     * Asks for the accessible route from the start. The visitor can still turn it off, and "Volver"
+     * goes back to it for the next visitor. Reads the attribute's value (see
+     * {@link defaultFalseBooleanConverter}), so `accessible-route="false"` is the walking route.
+     */
+    accessibleRoute: boolean;
+    /**
+     * Floor the route starts on, for an origin that exists on several floors (an elevator). Takes the
+     * floor's id (`InnerFloor.key`) and takes precedence over `origin-level`.
+     */
+    originFloorId: string;
+    /** Same as `origin-floor-id`, by the floor's level number instead of its id. */
+    originLevel: number | undefined;
+    /**
+     * Floor the route ends on, for a destination on several floors. Unlike `origin-floor-id`, "Volver"
+     * clears this one: it belongs to the last visitor's destination, not to the kiosk.
+     */
+    destinationFloorId: string;
+    /** Same as `destination-floor-id`, by level number. */
+    destinationLevel: number | undefined;
+    /** Hides the "Generar ruta" button, and turns on {@link autoGenerateRoute} with it. */
+    hideGenerateRoute: boolean;
+    /**
+     * Hides the QR card. Reads the attribute's value (see {@link defaultFalseBooleanConverter}), so
+     * `hide-qr="false"` keeps the card.
+     */
+    hideQr: boolean;
+    /** Requests and animates the route as soon as origin and destination are loaded, without waiting for "Generar ruta". */
+    autoGenerateRoute: boolean;
+    /** Whether routes are requested automatically: asked for, or implied by hiding the button. */
+    private get _routesAutomatically();
+    /** Route panel layout: `full` (default) or `compact`. The `hide-*` flags still apply on top. */
+    panelVariant: string;
+    /** Where the floor bar goes; see `<floor-selector>`'s `position` values. */
+    floorSelectorPosition: string | undefined;
+    /**
+     * Cache configuration for SDK data (places, routes, configurations, etc.). Defaults to
+     * {@link TOTEM_CACHE_CONFIG}, the preset built for this component's kiosk deployment. What is set
+     * here is merged **over that preset**, so a partial override changes only the entries it names.
+     */
+    cacheConfig: CacheConfig | undefined;
+    /** {@link cacheConfig} resolved against the kiosk preset it defaults to. */
+    private get _effectiveCacheConfig();
+    /**
+     * The destination place ID. Setting this property (even to the same value) clears the previous
+     * route and reloads the destination — handles a totem screen that re-selects the same destination
+     * (e.g. after being locked).
+     */
+    get destinationId(): string;
+    set destinationId(value: string);
+    private _destinationId;
+    /**
+     * Assigns `destinationId` without the same-value reload above. Used by {@link updateComponent},
+     * whose delegation to `<custom-map>`'s own `updateComponent()` already performed the load — a
+     * second one here would be a pointless, redundant `PlaceController.setOriginAndDestination` call.
+     */
+    private _setDestinationIdSilently;
+    /** Whether `firstUpdated` has run, enabling the destination-reload-on-same-value behavior above. */
+    private _hasInitialized;
+    /**
+     * Set while {@link updateComponent} syncs its own reflected properties after delegating the real
+     * work to `<custom-map>`'s own `updateComponent()`. Without it, those property assignments would
+     * also trigger this element's OWN reactive `willUpdate`/`updated` pair-load and
+     * accessible-route-reload paths below — redundantly reloading the very pair, and redundantly
+     * re-applying the very accessible-route preference, `<custom-map>` just finished applying.
+     *
+     * Invariant (Task 14 integration-pass note): {@link _maybeLoadPair}'s suppressed branch assumes
+     * nothing else can legitimately change the pair's identity while this flag is active — true today
+     * only because `updateComponent()` is this flag's one and only write site; re-verify that branch
+     * before ever flipping this flag from a second call site.
+     */
+    private _suppressPairLoad;
+    /**
+     * The pair's identity as last ACTUALLY requested through {@link _loadPair}, or `undefined` once
+     * the pair is incomplete or has never been requested. Compared against a fresh {@link _pairKey} by
+     * {@link _maybeLoadPair} to decide whether a load is due — independent of whether the id fields
+     * themselves changed in the CURRENT render pass (review round 2, see `_maybeLoadPair`'s own doc
+     * comment for why that independence is the fix).
+     */
+    private _pairRequestedFor;
+    /**
+     * A stable identity for the whole pair, not just `destinationId`: changing any one of these six
+     * fields is a different pair that needs its own load. `undefined` when there is no complete pair
+     * to load yet (no `originId` or no `destinationId`).
+     */
+    private _pairKey;
+    /**
+     * Whether {@link _maybeLoadPair} would start a fresh load for the pair as it stands right now: a
+     * complete pair, not already requested, with an SDK actually available for it. Read-only (no side
+     * effects, unlike `_maybeLoadPair` itself) — used by `willUpdate()` to decide whether an
+     * `accessibleRoute` change should apply straight to context (a load is about to replace the route
+     * anyway) or go through `RouteController.setAccessibleRoute()` (nothing else is about to touch the
+     * route this pass).
+     */
+    private _pairLoadPending;
+    /**
+     * Loads the pair through {@link _loadPair} once it is complete and an SDK is actually available for
+     * it. Checked on EVERY `updated()` pass — NOT gated on `changedProperties` naming the id fields,
+     * unlike the version this replaced (review round 2, the same load-ordering gap Task 10's own review
+     * found in `map-view-with-modal.ts`'s `maybeLoadPlace()`, ported here adapted to a full pair instead
+     * of a single id):
+     *
+     * A pair set in an EARLIER render pass than `apiKey`/`locale`/`parentPlaceId` would otherwise never
+     * load at all. `PlaceController.setOriginAndDestination()` silently no-ops with no SDK yet; by the
+     * time credentials finally arrive in their OWN, later pass, the id fields are no longer "changed"
+     * in THAT pass, so a `changedProperties`-gated check would never fire for them again — the pair
+     * would be stuck forever. Deduping on {@link _pairKey} (the identity actually last requested)
+     * instead of on Lit's own per-pass dirty-checking is what fixes this: a pair set before the SDK
+     * exists is simply never marked "handled" until a pass where the SDK really is ready picks it up.
+     * The same dedupe also means calling this unconditionally never causes a redundant re-fetch of an
+     * already-loaded pair.
+     *
+     * Respects {@link _suppressPairLoad} (set by {@link updateComponent} while it syncs its own
+     * reflected properties after `<custom-map>`'s own `updateComponent()` already did the real load):
+     * while suppressed, this still records the CURRENT key as `_pairRequestedFor` — without that, once
+     * suppression lifts, this method would see the pair `<custom-map>` just loaded as still "pending"
+     * (its key was never recorded) and fire a redundant reload for it, reopening the exact bug the
+     * first review round's `_suppressPairLoad` fix closed. This suppressed branch relies on nothing
+     * else legitimately changing the pair's identity while `_suppressPairLoad` is active — safe only
+     * because that flag has exactly one write site (`updateComponent()`); a second write site would
+     * need this branch re-checked, or it could silently drop a pair load it should have started.
+     *
+     * @returns `true` once it actually started a load this call, so `updated()`'s own
+     * auto-route-toggle branch does not duplicate the request `_loadPair()` already makes for a fresh pair.
+     */
+    private _maybeLoadPair;
+    /**
+     * Loads the current origin/destination pair, and the route too when routes are automatic.
+     *
+     * Clears the previous route first (review round 1, Important finding 2): without this, a route
+     * loaded for the pair being left stays in context — `RouteController` has no other call site that
+     * drops it on a plain property-driven pair change (unlike `<custom-map>`'s own `updateComponent()`,
+     * whose `replacePair()` clears it before loading). Left uncleared, three things went wrong: a
+     * same-value `destinationId` reload (the kiosk "re-select after screen lock" case) kept the stale
+     * route id; an origin-only change in auto mode never asked for a new route because
+     * `_requestRouteIfIdle()` saw the stale one and thought one already existed; and an origin-only
+     * change outside auto mode left the old, now-wrong route drawn on the map. `clearRoute()` also
+     * drops a route request still in flight for the pair being left, so its answer cannot land on this one.
+     *
+     * In auto mode the route is requested together with the places (`generateRoute({ after })`, the
+     * reference's route-alongside-places load): its `route` loading phase is raised before the
+     * `places` one ends, so `mvxLoadingChange` never reports the load as over between the two, and the
+     * request itself goes out once the places are in — with the floors the host asked for resolved
+     * against the loaded places — or not at all if they failed or a newer load superseded them.
+     */
+    private _loadPair;
+    /** Generates the route for the current pair, unless one is already loaded or loading. */
+    private _requestRouteIfIdle;
+    /** Context forwarded to MapVX API as `X-MapVx-*` and `mvx-product` request headers. */
+    private mapVxRequestContext;
+    /* Excluded from this release type: contextManager */
+    /* Excluded from this release type: placeController */
+    /* Excluded from this release type: routeController */
+    /* Excluded from this release type: floorController */
+    private readonly analyticsController;
+    /** The tiles service worker (see this class's doc comment), started in `firstUpdated()`. */
+    private readonly tileServiceWorker;
+    /**
+     * Keeps the compact route card clear of the vertical floor bar, however wide the floor names make
+     * it. Held only so it lives as long as the host: `protected` rather than `private` because
+     * `noUnusedLocals` rejects a private field that is never read (TS6133).
+     */
+    protected readonly floorSelectorSize: FloorSelectorSizeController;
+    constructor();
+    /**
+     * The inner `custom-map`. Always present (this element renders it unconditionally, unlike the
+     * lazily-loaded reference), so a plain cast is enough — no `Partial<>`/optional-chaining dance.
+     */
+    private _customMap;
+    firstUpdated(): void;
+    private sendEvent;
+    private _mapReadyHandler;
+    private _cameraInitializedHandler;
+    willUpdate(changedProperties: PropertyValues): void;
+    updated(changedProperties: PropertyValues): void;
+    render(): TemplateResult<1>;
+    private _floorChangeHandler;
+    private _accessibilityChangeHandler;
+    private _repeatRouteHandler;
+    private _generateRouteHandler;
+    private _backHandler;
+    /**
+     * Turns `<custom-map>`'s `startRouteAnimation`/`routeAnimationFinished` events, and
+     * `<route-options>`'s `repeatRoute` event, into the matching `RouteController` call. This is the
+     * wiring Task 8b's review found missing (its M2): without it, `routeData.isAnimating` stays `true`
+     * forever once a route finishes naturally, which `<custom-map>`'s stall-recovery branch
+     * (`restartStalledRoute`) reads as "stalled" and restarts — an endless replay loop. See
+     * `route-view-totems.test.ts`'s "route animation wiring" suite for the regression test proving a
+     * natural finish does not trigger a restart.
+     */
+    private _startRouteAnimationHandler;
+    private _routeAnimationFinishedHandler;
+    private _dismissRouteErrorHandler;
+    /**
+     * Updates the component's origin/destination/floor/route-type without requiring a "back" event.
+     * Delegates to the inner `<custom-map>`'s own `updateComponent()` (see this class's doc comment for
+     * why the real work lives there), then keeps this element's own reflected properties in step with
+     * what was actually requested.
+     *
+     * @param params - Parameters for the update
+     * @returns Promise resolving to the result of the update operation
+     * @example
+     * ```typescript
+     * const result = await totemView.updateComponent({ destinationId: 'PDP_N1_1036' });
+     * if (result.success) {
+     *   console.log('Updated from', result.previousDestinationId, 'to', result.newDestinationId);
+     * }
+     * ```
+     */
+    updateComponent(params: UpdateComponentParams): Promise<UpdateComponentResult>;
+    /**
+     * Clears the map of routes and destination markers, keeping the origin.
+     * @param preserveOrigin - Whether to preserve the origin marker (default: true)
+     */
+    clearMap(preserveOrigin?: boolean): Promise<void>;
+    /**
+     * Destroys the map and builds a fresh one, keeping venue, origin, destination and route.
+     * @example
+     * ```ts
+     * document.querySelector('route-view-totems')?.reloadMap();
+     * ```
+     */
+    reloadMap(): void;
+    /**
+     * Whether a load is in progress: places, route or camera. Independent of whether anything is
+     * painted, so `hide-loading` does not make it `false`.
+     */
+    isLoading(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+/**
+ * Schedules periodic tile warmup (same message as initial load). Returns a cleanup function.
+ */
+export declare function schedulePeriodicTileRefresh(registration: ServiceWorkerRegistration | null | undefined, options: MvxTilePrefetchOptions, intervalMs?: number): () => void;
+
+/**
+ * Context type for SDK core state.
+ */
+declare interface SDKContextType {
+    /** The initialized SDK instance */
+    sdk?: MapVXSDK;
+    /** Current locale for SDK operations */
+    locale?: string;
+    /** Parent place ID for SDK scope */
+    parentPlaceId?: string;
+}
+
+/**
+ * Storage size constants in bytes.
+ *
+ * @description Helper constants for defining storage limits in cache configurations. Used as
+ * {@link CacheConfig.maxStorageBytes}, the SDK reads them as UTF-16 code units, not bytes.
+ *
+ * @example
+ * ```typescript
+ * import { STORAGE_BYTES } from '@mapvx/web-kit';
+ *
+ * const config = {
+ *   maxStorageBytes: STORAGE_BYTES.MB_10, // 10MB limit
+ * };
+ * ```
+ */
+export declare const STORAGE_BYTES: {
+    /** 2 megabytes in bytes (2,097,152) */
+    readonly MB_2: number;
+    /** 5 megabytes in bytes (5,242,880) */
+    readonly MB_5: number;
+    /** 10 megabytes in bytes (10,485,760) */
+    readonly MB_10: number;
+};
+
+/**
+ * Time constants in milliseconds for readability.
+ *
+ * @description Helper constants for defining TTL values in cache configurations.
+ *
+ * @example
+ * ```typescript
+ * import { TIME_MS } from '@mapvx/web-kit';
+ *
+ * const ttl = 15 * TIME_MS.MINUTE; // 15 minutes in ms
+ * const longTtl = 2 * TIME_MS.HOUR; // 2 hours in ms
+ * ```
+ */
+export declare const TIME_MS: {
+    /** One minute in milliseconds (60,000) */
+    readonly MINUTE: number;
+    /** One hour in milliseconds (3,600,000) */
+    readonly HOUR: number;
+};
+
+/**
+ * Cache configuration optimized for totem/kiosk deployments.
+ *
+ * @description Designed for dedicated hardware running continuously:
+ * - 2MB storage limit per cache type: a large mall's store lists in two languages fit (1.8 M
+ *   measured for Costanera), and no single type can fill the 5 M an origin gets on its own. A
+ *   third language would not fit: the SDK then stops writing that type and keeps the copy it has
+ * - Longer TTLs (1-4 hours) to reduce API calls
+ * - Persistent storage enabled for fast cold starts
+ *
+ * Unlike {@link WEB_CACHE_CONFIG}, store lists (`subPlaces`) are persisted too. A kiosk shows one
+ * venue on a page no host shares, so they take a bounded share of storage nothing else competes
+ * for, and a reload does not download the largest response again. The SDK also seeds every store
+ * it downloads into `places`, so on a large venue the stores fill that cache as well: about 1.5 of
+ * the 1.6 MB a Costanera totem stores is store data, kept twice.
+ *
+ * Recommended for: Digital signage, wayfinding kiosks, information totems.
+ *
+ * @example
+ * ```typescript
+ * import { TOTEM_CACHE_CONFIG } from '@mapvx/web-kit';
+ *
+ * // Use directly
+ * <route-view-totems
+ *   apiKey="your-api-key"
+ *   parentPlaceId="venue-id"
+ *   .cacheConfig=${TOTEM_CACHE_CONFIG}
+ * />
+ * ```
+ *
+ * | Cache Type       | Max Items | TTL        | Persisted |
+ * |------------------|-----------|------------|-----------|
+ * | places           | 500       | 2 hours    | yes       |
+ * | subPlaces        | 200       | 1 hour     | yes       |
+ * | routes           | 100       | 15 minutes | yes       |
+ * | accessibleRoutes | 100       | 15 minutes | yes       |
+ * | configurations   | 10        | 4 hours    | yes       |
+ * | categories       | 50        | 2 hours    | yes       |
+ * | vehicles         | 20        | 30 minutes | yes       |
+ * | stops            | 50        | 30 minutes | yes       |
+ * | styles           | 20        | 24 hours   | yes (SDK default) |
+ */
+export declare const TOTEM_CACHE_CONFIG: CacheConfig;
+
+/**
+ * Asks the active service worker to run bounded progressive tile prefetch.
+ */
+export declare function triggerInitialTileLoad(registration: ServiceWorkerRegistration | null | undefined, options: MvxTilePrefetchOptions): void;
+
+/**
+ * Context type for UI-related state.
+ */
+declare interface UIContextType {
+    /** Currently selected floor */
+    currentFloor?: InnerFloor;
+    /** All available floors in the parent place */
+    allFloors: InnerFloor[];
+    /** Markers to display on the map */
+    markers: MarkerContext[];
+    /** Whether the map is fully loaded and ready */
+    mapReady: boolean;
+    /** Whether the camera has been initialized with proper view */
+    cameraInitialized: boolean;
+}
+
+/**
+ * Parameters for updating the map component programmatically. Same shape as the reference's
+ * `custom-map.ts` (there, just a type; the reference's actual `updateComponent()` lives on
+ * `route-view-totems.ts` — see the class doc for why it lives here instead in web-kit).
+ */
+export declare interface UpdateComponentParams {
+    /** New destination ID to navigate to */
+    destinationId?: string;
+    /** New origin ID (optional, defaults to current origin) */
+    originId?: string;
+    /**
+     * Floor the route starts on, for an origin on several floors (an elevator). Takes precedence over
+     * `originLevel`. A new `originId` given without a floor clears the previous one.
+     */
+    originFloorId?: string;
+    /** Level of the floor the route starts on. Prefer `originFloorId`; see `origin-level`. */
+    originLevel?: number;
+    /** Same as `originFloorId`, for the destination. A new `destinationId` without a floor clears it. */
+    destinationFloorId?: string;
+    /** Same as `originLevel`, for the destination. */
+    destinationLevel?: number;
+    /** Asks for the accessible route (elevators over stairs and escalators). */
+    accessibleRoute?: boolean;
+    /** Floor shown in the floor selector (optional). Not where the route starts. */
+    floor?: string;
+}
+
+/** Result of an {@link CustomMap.updateComponent} call. Ported from the reference's `route-view-totems.ts`. */
+export declare interface UpdateComponentResult {
+    success: boolean;
+    error?: string;
+    previousDestinationId?: string;
+    newDestinationId?: string;
+}
+
+/**
+ * Waits for whichever service worker registration's scope covers this page.
+ *
+ * @description Kept because it is the behaviour published up to v0.13.0, and dropping it would
+ * break every existing caller — silently for plain-JS importers, where there is no compiler to
+ * complain. It waits for the registration whose scope covers the page, which need not be the tiles
+ * one: with a host worker at a narrower scope it returns while the tiles worker is still
+ * installing, and `triggerInitialTileLoad` then drops the prefetch. Per spec it never rejects, and
+ * it never resolves at all while no registration covers the page.
+ *
+ * This signature comes first on purpose: TypeScript reads the **last** overload for
+ * `Parameters<>` and for inference into generic functions, so putting it last would type the
+ * function as `() => Promise<void>` and push callers towards the form being deprecated.
+ * @deprecated Pass the registration {@link registerMvxTileServiceWorker} returned.
+ * @returns A promise that resolves once some registration covering the page has an active worker
+ * @example
+ * // Prefer this instead:
+ * const registration = await registerMvxTileServiceWorker();
+ * await waitForServiceWorkerReady(registration);
+ */
+export declare function waitForServiceWorkerReady(): Promise<void>;
+
+/**
+ * Waits until a tiles service worker registration can receive messages.
+ *
+ * @description Resolves as soon as `registration` has a messageable worker, and immediately when
+ * there is nothing to wait for. `null` and `undefined` both mean that: `registerMvxTileServiceWorker`
+ * returns `null` when it could not register, and `ServiceWorkerContainer.getRegistration` resolves
+ * to `undefined` when nothing matches. Treating either as "wait for the page instead" is how this
+ * used to hang for the life of the page.
+ * @param registration - The registration {@link registerMvxTileServiceWorker} returned, or
+ * `null`/`undefined` when there is none
+ * @returns A promise that resolves once the worker can be messaged, or immediately when there is
+ * nothing to wait for
+ * @example
+ * const registration = await registerMvxTileServiceWorker();
+ * await waitForServiceWorkerReady(registration);
+ * if (registration) {
+ *   triggerInitialTileLoad(registration, { apiKey: 'key', placeId: 'place' });
+ * }
+ */
+export declare function waitForServiceWorkerReady(registration: ServiceWorkerRegistration | null | undefined): Promise<void>;
+
+/**
+ * Cache configuration optimized for web browser usage.
+ *
+ * @description Designed for standard website visitors:
+ * - 5MB storage limit per cache type
+ * - Shorter TTLs (5-60 minutes) for fresher data
+ * - Persistent storage enabled for return visitors, except for store lists and map styles
+ *
+ * Store lists (`subPlaces`) stay in memory only. They are the largest entry, 0.85 MB for one
+ * language of a large mall, and they pile up with every venue a visitor opens, in the localStorage
+ * the host page shares with the components: twelve venues took 3.3 MB of the 5 MB that Chrome
+ * gives an origin (MFE-272). The stores themselves still reach localStorage one by one, because the
+ * SDK seeds every store it downloads into `places`, which is persisted; `places.maxItems` bounds
+ * them (about 280 KB here).
+ *
+ * Map styles (`styles`) stay in memory too, at about 50 KB per venue: twelve venues stored 561 KB
+ * of them. SDK 4.0.1 kept both lists and styles in memory, in a cache of the map's own.
+ *
+ * Recommended for: Website embeds, mobile web apps, standard deployments.
+ *
+ * @example
+ * ```typescript
+ * import { WEB_CACHE_CONFIG } from '@mapvx/web-kit';
+ *
+ * // Use directly
+ * <map-view-with-modal
+ *   apiKey="your-api-key"
+ *   parentPlaceId="venue-id"
+ *   .cacheConfig=${WEB_CACHE_CONFIG}
+ * />
+ * ```
+ *
+ * | Cache Type       | Max Items | TTL        | Persisted |
+ * |------------------|-----------|------------|-----------|
+ * | places           | 200       | 30 minutes | yes       |
+ * | subPlaces        | 100       | 15 minutes | no        |
+ * | routes           | 50        | 5 minutes  | yes       |
+ * | accessibleRoutes | 50        | 5 minutes  | yes       |
+ * | configurations   | 10        | 1 hour     | yes       |
+ * | categories       | 30        | 1 hour     | yes       |
+ * | vehicles         | 10        | 5 minutes  | yes       |
+ * | stops            | 20        | 5 minutes  | yes       |
+ * | styles           | 20        | 24 hours   | no        |
+ */
+export declare const WEB_CACHE_CONFIG: CacheConfig;
+
+export { }
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'route-view-totems': RouteViewTotems;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'map-view-with-modal': MapViewWithModal;
+    }
+}
+
+
+declare global {
+    interface HTMLElementEventMap {
+        mvxError: CustomEvent<MvxErrorDetail>;
+        /**
+         * The route started animating onto the map.
+         *
+         * **Also fires on every route repeat**, not only the first one, so treat it as "a route is
+         * being drawn now" rather than "the first load finished". For the end of a load use
+         * {@link HTMLElementEventMap.mvxLoadingChange}.
+         */
+        startRouteAnimation: CustomEvent<void>;
+        /**
+         * The camera finished framing its target.
+         *
+         * **Not the end of the load.** With `auto-generate-route` the route is requested alongside the
+         * two places, so the camera frames them and fires this while the route is still being
+         * generated — seconds before it appears. A host indicator taken down here leaves the visitor
+         * on an empty map waiting for a route with nothing to say so.
+         *
+         * For the end of a load use {@link HTMLElementEventMap.mvxLoadingChange} with
+         * `detail.loading === false`, which is the one signal the built-in overlay itself goes down on.
+         */
+        cameraInitialized: CustomEvent<Record<string, never>>;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'custom-map': CustomMap;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'compact-floor-selector': CompactFloorSelector;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'floor-selector': FloorSelector;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'route-options': RouteOptions;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'qr-modal': QRModal;
+    }
+}
+
+
+declare global {
+    interface Window {
+        dataLayer: unknown[];
+        gtag: (...args: unknown[]) => void;
+    }
+}
+
+
+declare global {
+    interface HTMLElementEventMap {
+        /**
+         * The loading state changed, with the phase that caused it. One event per transition, and
+         * `detail.loading === false` is the end of the load — the same moment the built-in indicator
+         * goes down.
+         */
+        mvxLoadingChange: CustomEvent<MvxLoadingChangeDetail>;
+    }
+}
+
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'map-loading-overlay': MapLoadingOverlay;
+    }
+}