@mappedin/mappedin-js 6.18.0 → 6.20.0

package/lib/esm/index.d.ts

@@ -1,8 +1,8 @@
-import * as _mappedin_mvf_v28 from "@mappedin/mvf-v2";
+import * as _mappedin_mvf_v25 from "@mappedin/mvf-v2";
 import { AnnotationCollection, AnnotationSymbol, AreaCollection, AreaId, BaseTextAreaProperties, Category, CategoryId, Connection as Connection$1, Details, EnterpriseCategory as EnterpriseCategory$1, EnterpriseCategoryId, EnterpriseLocation as EnterpriseLocation$1, EnterpriseLocationId, EnterpriseLocationInstance, EnterpriseTexture, EnterpriseVenue as EnterpriseVenue$1, EnterpriseVenueType, EntranceCollection, EntranceFeature, Facade as Facade$1, Feature as Feature$1, FeatureCollection as FeatureCollection$1, FloatingFloorTextProperties, FloorCollection, FloorId, FloorProperties, FloorStack as FloorStack$1, FloorTextCommonProperties, Geometry as Geometry$1, Hyperlink as Hyperlink$1, Image, Language, LineStringStyle, LineStringStyle as TMVFLineStringStyle, Location, LocationId, LocationLink, LocationSocial, LocationSocial as LocationSocial$1, LocationState, LocationState as LocationState$1, MVFv2_STANDARD_MVFv3, MultiPolygon as MultiPolygon$1, NavigationFlagDeclarations, NodeCollection, NodeId, ObstructionCollection, ObstructionCollection as ObstructionCollection$1, ObstructionFeature, ObstructionId, OpeningHoursSpecification, OperationHours, OperationHours as OperationHours$1, ParsedMVF, ParsedMVF as TMVF, ParsedMVFLocalePack, Point as Point$1, PointStyle, PointStyle as TMVFPointStyle, Polygon as Polygon$1, PolygonStyle, PolygonStyle as TMVFPolygonStyle, SiblingGroup, SiblingGroup as SiblingGroup$1, SpaceCollection, SpaceCollection as SpaceCollection$1, SpaceFeature, SpaceId, SpaceProperties, Style as TMVFStyle, StyleCollection, StyleCollection as TMVFStyleCollection, TilesetStyle } from "@mappedin/mvf-v2";
 import { MVFv2_STANDARD_MVFv3 as MVFv2_STANDARD_MVFv3$1, ParsedMVF as ParsedMVF$1, RawMVF } from "@mappedin/mvf-v2/no-validator-lite";
 import * as _mappedin_renderer_three0 from "@mappedin/renderer-three";
-import { AddLabelOptionsInternal, AddText3DOptions, AddText3DOptions as AddText3DOptions$1, AddText3DPointOptions, CameraSystemState, ColorString, DebugState, DebugState as DebugState$1, EntityId, EnvMapOptions, EnvMapOptions as EnvMapOptions$1, GLTFExportOptions as GLTFExportOptions$1, GroupContainerState, ISystemPlugin, ISystemPlugin as ISystemPlugin$1, ImagePlacementOptions, InitializeModelState, InitializeModelState as InitializeModelState$1, InitializeText3DState, InsetPadding, InsetPadding as InsetPadding$1, InsetPaddingOption, InsetPaddingOption as InsetPaddingOption$1, InterpolateOn, Interpolation, LabelAppearance as LabelAppearance$1, LabelRenderedState, LabelTextPlacement as LabelTextPlacement$1, LineStyle, LineStyle as LineStyle$1, MapViewState, MarkerState, OutlinesOptions, PaintStyle, PaintStyle as PaintStyle$1, PathState, PathWidth, PathWidth as PathWidth$1, PixelWidth, Position as Position$1, RendererCore, RendererCoreOptions, Shading, Text3DState, WatermarkUpdateOptions } from "@mappedin/renderer-three";
+import { AddLabelOptionsInternal, AddText3DOptions, AddText3DOptions as AddText3DOptions$1, AddText3DPointOptions, CameraSystemState, ColorString, DebugState, DebugState as DebugState$1, EntityId, EnvMapOptions, EnvMapOptions as EnvMapOptions$1, GLTFExportOptions as GLTFExportOptions$1, GroupContainerState, ISystemPlugin, ISystemPlugin as ISystemPlugin$1, ImagePlacementOptions, InitializeModelState, InitializeModelState as InitializeModelState$1, InitializeText3DState, InsetPadding, InsetPadding as InsetPadding$1, InsetPaddingOption, InsetPaddingOption as InsetPaddingOption$1, InterpolateOn, Interpolation, LabelRenderedState, LineStyle, LineStyle as LineStyle$1, MapViewState, MarkerState, OutlinesOptions, PaintStyle, PaintStyle as PaintStyle$1, PathState, PathWidth, PathWidth as PathWidth$1, PixelWidth, Position as Position$1, RendererCore, RendererCoreOptions, RendererCoreOptions as RendererCoreOptions$1, Shading, Text3DState, WatermarkUpdateOptions } from "@mappedin/renderer-three";
 import * as _tweenjs_tween_js0 from "@tweenjs/tween.js";
 import { Group, Tween } from "@tweenjs/tween.js";
 import { CustomLayerInterface, IControl, Map as Map$1, MapEventType } from "@mappedin/outdoor-context";
@@ -209,6 +209,11 @@ type TSearchOptions = {
    */
   enabled: boolean;
 };
+/**
+ * Options shared by every {@link getMapData} call regardless of authentication mode.
+ * Carries the target `mapId` and optional overrides such as environment, base URL,
+ * and language preferences.
+ */
 type TGetMapDataSharedOptions = {
   /**
    * Mappedin map ID.
@@ -304,8 +309,12 @@ type TGetMapDataSharedOptions = {
    */
   prefetchTokens?: boolean;
   /**
-   * @hidden
-   * @internal
+   * Load draft (unpublished) enterprise map instead of the live version.
+   * Set to `"draft"` to fetch the latest unpublished changes.
+   * Leave unspecified to load the published live data.
+   *
+   * Requires an Enterprise API key. Only applicable to maps made in Mappedin CMS.
+   * @default undefined
    */
   layoutId?: 'draft';
   /**
@@ -344,6 +353,8 @@ type TGetMapDataWithCredentialsOptions = {
   secret: string;
 } & TGetMapDataSharedOptions;
 /**
+ * {@link getMapData} options that authenticate with a pre-issued access token,
+ * as opposed to a `key`/`secret` pair.
  * @interface
  */
 type TGetMapDataWithAccessTokenOptions = {
@@ -352,6 +363,10 @@ type TGetMapDataWithAccessTokenOptions = {
    */
   accessToken: string;
 } & TGetMapDataSharedOptions;
+/**
+ * Options accepted by {@link getMapData}. Either credentials (`key`/`secret`) or an
+ * `accessToken` may be supplied alongside the shared options.
+ */
 type TGetMapDataOptions = TGetMapDataWithCredentialsOptions | TGetMapDataWithAccessTokenOptions;
 /**
  * @internal
@@ -399,9 +414,21 @@ type ParsedMVFResult = {
   mvf2: ParsedMVF$1;
   mvf3?: MVFv2_STANDARD_MVFv3$1;
 };
+/**
+ * Decompress and parse a binary MVF (Mappedin Venue Format) payload into the
+ * structured `ParsedMVFResult` consumed by {@link hydrateMapData}.
+ *
+ * @param data - The gzipped MVF binary payload.
+ * @param inputVersion - The MVF schema version to parse against.
+ */
 declare function unzipAndParseMVFv2(data: Uint8Array, inputVersion?: string): Promise<ParsedMVFResult>;
 //#endregion
 //#region src/hydrate-map-data.d.ts
+/**
+ * Pre-fetched MVF data passed to {@link hydrateMapData} so a map can be constructed
+ * without going to the network. Supports both binary (`Uint8Array`) and JSON forms,
+ * optional language packs, and matches the shape produced by Mappedin's CDN.
+ */
 type THydrateMapDataBundle = {
   type: 'binary';
   options?: {
@@ -599,8 +626,19 @@ type CaptureEventsPayloadMap = {
      * Optional array of result IDs (hits).
      */
     hits?: string[];
+    /**
+     * Total number of results returned for the query across all result categories
+     * (places + enterprise locations + enterprise categories). Useful for identifying
+     * queries that return no results (`resultCount === 0`).
+     */
+    resultCount?: number;
   };
 };
+/**
+ * Sends user interaction analytics events to Mappedin's analytics backend.
+ * Captures map loads, search queries, directions, and custom user events so
+ * usage of an indoor map can be measured and tuned.
+ */
 declare class Analytics {
   #private;
   /**
@@ -635,6 +673,12 @@ declare class Analytics {
     analyticsBaseUrl: string;
     /** Flag to disable authentication. */
     noAuth: boolean;
+    /**
+     * Marks the tenant as an enterprise venue. Only enterprise venues are allowed to send
+     * `x-mappedin-key` / `x-mappedin-secret` headers to the analytics gateway — non-enterprise
+     * tenants must use `accessToken` (Bearer) auth, otherwise the gateway returns 401.
+     */
+    enterprise: boolean;
     /** Flag to enable geolocation mode. */
     geolocationMode: boolean;
     /** The context in which the analytics are being used. */
@@ -689,6 +733,12 @@ type AnalyticState = {
   analyticsBaseUrl: string;
   /** Flag to disable authentication. */
   noAuth: boolean;
+  /**
+   * Marks the tenant as an enterprise venue. Only enterprise venues are allowed to send
+   * `x-mappedin-key` / `x-mappedin-secret` headers to the analytics gateway — non-enterprise
+   * tenants must use `accessToken` (Bearer) auth, otherwise the gateway returns 401.
+   */
+  enterprise: boolean;
   /** Flag to enable geolocation mode. */
   geolocationMode: boolean;
   /** @internal The device ID to be used for analytics. */
@@ -3056,6 +3106,15 @@ declare const LABEL_TEXT_PLACEMENT: {
   readonly CENTER: "center";
 };
 declare const LABEL_LOW_PRIORITY = "low-priority";
+/**
+ * The placement of a label's text relative to its pin.
+ *
+ * - `'right'` — text appears to the right of the pin.
+ * - `'left'` — text appears to the left of the pin.
+ * - `'top'` — text appears above the pin.
+ * - `'hidden'` — text is hidden, only the pin is visible.
+ * - `'center'` — text is centered at the pin location and the pin is hidden.
+ */
 type LabelTextPlacement = (typeof LABEL_TEXT_PLACEMENT)[keyof typeof LABEL_TEXT_PLACEMENT];
 type LabelTextPlacementInternal = LabelTextPlacement | typeof LABEL_LOW_PRIORITY;
 type EasingCurve$1 = string;
@@ -3108,7 +3167,66 @@ declare const labelAppearanceSchemaBase: ZodObject<{
   __EXPERIMENTAL_wrapperShadowOffsetX: ZodDefault<ZodNumber>;
   __EXPERIMENTAL_wrapperShadowOffsetY: ZodDefault<ZodNumber>;
   __EXPERIMENTAL_wrapperShadowBlur: ZodDefault<ZodNumber>;
+  __EXPERIMENTAL_wrapperOpacity: ZodDefault<ZodNumber>;
 }, $strip>;
+/**
+ * Options to control how a label is rendered.
+ *
+ * | Option | Type | Description | Default |
+ * |--------|------|-------------|---------|
+ * | `margin` | `number` | Margin around the label text and pin in pixels. This will affect label density. Minimum is 6px. | 6 |
+ * | `maxLines` | `number` | Number of lines to display when text spans multiple lines. | 2 |
+ * | `textSize` | `number` | Text size in pixels | 11.5 |
+ * | `maxWidth` | `number` | Maximum width of text in pixels. | 150 |
+ * | `lineHeight` | `number` | Line height sets the height of a line box. It's commonly used to set the distance between lines of text. | 1.2 |
+ * | `color` | `string` | A color string for the label text and pin. | `#333` |
+ * | `outlineColor` | `string` | A color string for the outline around the label text and pin. | `white` |
+ * | `textColor` | `string` | A color string representing just the text color. Defaults to the same as `color`. | - |
+ * | `textOutlineColor` | `string` | A color string representing just the text outline. Defaults to the same as `outlineColor`. | - |
+ * | `pinColor` | `string` | A color string representing just the pin color. Defaults to the same as `color`. | - |
+ * | `pinOutlineColor` | `string` | A color string representing just the pin outline. Defaults to the same as `outlineColor`. | - |
+ * | `pinColorInactive` | `string` | A color string representing just the pin color when the label is inactive. Defaults to the same as `pinColor`. | - |
+ * | `pinOutlineColorInactive` | `string` | A color string representing just the pin outline when the label is inactive. Defaults to the same as `pinOutlineColor`. | - |
+ * | `icon` | `string` | An icon to be placed inside the label pin. Can be an SVG string or a path to a PNG or JPEG. | - |
+ * | `iconSize` | `number` | Size of the icon in pixels. Requires `icon` to be set. | 20 |
+ * | `iconScale` | `number` \| {@link Interpolation} | Scale the icon uniformly. Specify a number or an {@link Interpolation} object. | 1 |
+ * | `iconPadding` | `number` | Padding between the icon and the pin's border in pixels. | 2 |
+ * | `iconFit` | `'fill'` \| `'contain'` \| `'cover'` | How the icon should fit inside the pin. Options: `fill` (stretch to fill), `cover` (maintain aspect ratio and fill), `contain` (maintain aspect ratio and fit inside). | `cover` |
+ * | `iconOverflow` | `'visible'` \| `'hidden'` | Whether the icon should overflow the circle of the pin. | `hidden` |
+ * | `iconVisible` | `boolean` \| `number` | Controls icon visibility. If boolean, directly shows/hides the icon. If number, defines the zoom level at which the icon becomes visible. | `true` |
+ * | `opacity` | `number` | The opacity of the Label when it is enabled and visible. | `1` |
+ *
+ * @example Render a label with an SVG icon
+ * ```ts
+ * mapView.Labels.add(space, "Label", {
+ * 	appearance: {
+ * 		icon: `<svg>...</svg>`,
+ * 	},
+ * });
+ * ```
+ *
+ * @example Render a label with an image icon
+ * ```ts
+ * mapView.Labels.add(space, "Label", {
+ * 	appearance: {
+ * 		icon: 'https://example.com/icon.png',
+ * 	},
+ * });
+ * ```
+ *
+ * @example Scale a label's icon with zoom level
+ * ```ts
+ * mapView.Labels.add(space, "Label", {
+ * 	appearance: {
+ * 		iconScale: {
+ * 			on: 'zoom-level',
+ * 			input: [19, 22],
+ * 			output: [1, 3],
+ * 		},
+ * 	},
+ * });
+ * ```
+ */
 type LabelAppearance = Partial<input<typeof labelAppearanceSchemaBase>> & {
   iconScale?: number | Interpolation$2<'zoom-level', number[]>;
 };
@@ -3156,6 +3274,7 @@ declare const labelAppearanceSchema: ZodPipe<ZodObject<{
   __EXPERIMENTAL_wrapperShadowOffsetX: ZodDefault<ZodNumber>;
   __EXPERIMENTAL_wrapperShadowOffsetY: ZodDefault<ZodNumber>;
   __EXPERIMENTAL_wrapperShadowBlur: ZodDefault<ZodNumber>;
+  __EXPERIMENTAL_wrapperOpacity: ZodDefault<ZodNumber>;
 }, $strip>, ZodTransform<Required<LabelAppearance>, {
   margin: number;
   maxLines: number;
@@ -3183,6 +3302,7 @@ declare const labelAppearanceSchema: ZodPipe<ZodObject<{
   __EXPERIMENTAL_wrapperShadowOffsetX: number;
   __EXPERIMENTAL_wrapperShadowOffsetY: number;
   __EXPERIMENTAL_wrapperShadowBlur: number;
+  __EXPERIMENTAL_wrapperOpacity: number;
   textColor?: string | undefined;
   textOutlineColor?: string | undefined;
   pinColor?: string | undefined;
@@ -3252,6 +3372,7 @@ declare class LabelComponent {
   interactive: boolean;
   isOccluded: boolean;
   offscreen: boolean;
+  disposed: boolean;
   /**
    * Whether the label can be shown, which is decided by the collision engine
    */
@@ -4371,7 +4492,99 @@ declare class Path implements IFocusable {
 declare const EASING_CURVES: readonly ["ease-in", "ease-out", "ease-in-out", "linear", "ease-out-cubic"];
 type EasingCurve = (typeof EASING_CURVES)[number];
 //#endregion
+//#region src/navigation/tethered.d.ts
+/**
+ * Preset visual styles for the connector line drawn from the tracked
+ * coordinate to the path when outside the tether threshold.
+ *
+ * - `'dashed-boxes'` — chunky 1m absolute dashes (default). Reads loudly as
+ *   "off-route".
+ * - `'dashed-stripes'` — long dashes with tiny gaps. Almost-solid striped look.
+ * - `'dashed-sparse'` — same dash size as `dashed-boxes` but with a much
+ *   bigger gap. Quieter, more breathable rhythm.
+ * - `'solid'` — continuous solid line, no dashing. A plain leader line.
+ * - `'bordered'` — ribbon geometry with darkened edges. Reads as a
+ *   warning ribbon. Forces ribbon geometry on the connector.
+ *
+ * For fine-grained control (custom colour, exact width, etc.) use
+ * `outsideThresholdPathOptions` — it is merged on top of the preset and
+ * wins on any conflicting properties.
+ */
+type TOutsideThresholdPathStyle = 'solid' | 'dashed-boxes' | 'dashed-stripes' | 'dashed-sparse' | 'bordered';
+/**
+ * Options for tethering to a coordinate.
+ */
+type TTetheredOptions = {
+  /**
+   * The distance threshold within which the coordinate will be tethered to the path (meters).
+   * @default 10
+   */
+  tetherThresholdDistance?: number;
+  /**
+   * Visual preset for the connector line drawn from the tracked coordinate
+   * to the path when outside the tether threshold. See
+   * {@link TOutsideThresholdPathStyle} for the list of presets.
+   *
+   * For finer control, use {@link outsideThresholdPathOptions} which is
+   * merged on top of the preset.
+   *
+   * @default 'dashed-boxes'
+   */
+  outsideThresholdPathStyle?: TOutsideThresholdPathStyle;
+  /**
+   * Low-level overrides applied on top of {@link outsideThresholdPathStyle}.
+   * Anything specified here wins over the preset.
+   */
+  outsideThresholdPathOptions?: Partial<TAddPathOptions>;
+  /**
+   * Options for the tether path (solid path from threshold point to destination).
+   */
+  tetherPathOptions?: Partial<TAddPathOptions>;
+  /**
+   * Controls behavior when the coordinate is outside the threshold distance from the path.
+   * - `'tether-and-dash'`: Creates both the tethered path and a dashed line from user to threshold point (default)
+   * - `'tether-only'`: Creates only the tethered path, no dashed line
+   * - `'untether'`: Untethers from the path until a coordinate within threshold is provided
+   * @default 'tether-and-dash'
+   */
+  coordinateOutsideThresholdMode?: 'tether-and-dash' | 'tether-only' | 'untether';
+  /**
+   * Whether to hide markers on the portion of the path the user has already travelled past.
+   * Markers on the remaining path (current segment ahead of the user and all subsequent
+   * segments, including the destination marker) stay enabled.
+   * @default false
+   */
+  hideMarkersOutsideThreshold?: boolean;
+};
+//#endregion
+//#region src/navigation/travelled.d.ts
+/**
+ * Options for updating travelled path state.
+ */
+type TTravelledOptions = {
+  /**
+   * The color to use for the travelled portion of the path.
+   * @default '#999'
+   */
+  color?: string;
+};
+//#endregion
 //#region src/navigation/index.d.ts
+/**
+ * Options for tracking a coordinate on the navigation path.
+ */
+type TTrackCoordinateOptions = {
+  /**
+   * The tracking mode to use.
+   * - 'tethered': Connect the user's position to the closest point on the path
+   * - 'travelled': Show the travelled portion of the path with a different color
+   */
+  mode: 'tethered' | 'travelled';
+} & (({
+  mode: 'tethered';
+} & TTetheredOptions) | ({
+  mode: 'travelled';
+} & TTravelledOptions));
 /**
  * Controls marker creation for navigation points.
  *
@@ -4503,6 +4716,11 @@ type TNavigationOptions = {
     animated?: boolean;
   };
 };
+/**
+ * Snapshot of the navigation system's state at a point in time, including the
+ * active floors, paths, and directions. Returned by `Navigation.getState()` and
+ * suitable for serialization or use in undo/redo flows.
+ */
 type NavigationState = {
   isMultiFloor: boolean;
   floorStacks: FloorStack[];
@@ -4600,6 +4818,102 @@ declare class Navigation {
    */
   setActivePathByDirections(target: Directions): void;
   clearHighlightedPathSection(): void;
+  /**
+   * Tracks the user's position on the navigation path using the specified mode.
+   * Only one tracking mode can be active at a time — switching modes auto-clears
+   * the previous mode's visual state.
+   *
+   * Call this on every position update (e.g. from BlueDot's `dot-position-update`
+   * event). Use {@link stopTracking} to tear down all tracking state.
+   *
+   * @param coordinate - The user's current coordinate
+   * @param options - Tracking options including mode ('tethered' or 'travelled') and mode-specific options
+   * @returns For 'tethered' mode: path coordinates if successful, null otherwise.
+   *          For 'travelled' mode: the travelled fraction (0-1) if successful, null otherwise.
+   * @experimental
+   *
+   * @example
+   * ```ts
+   * // 'tethered' — snap user position onto the closest point on the active path
+   * blueDot.on('dot-position-update', e => {
+   *   mapView.Navigation.trackCoordinate(e.position, {
+   *     mode: 'tethered',
+   *     tetherThresholdDistance: 10,
+   *     coordinateOutsideThresholdMode: 'tether-and-dash',
+   *     outsideThresholdPathStyle: 'dashed-boxes',
+   *   });
+   * });
+   *
+   * // 'travelled' — recolour the portion of the path the user has walked past
+   * blueDot.on('dot-position-update', e => {
+   *   mapView.Navigation.trackCoordinate(e.position, {
+   *     mode: 'travelled',
+   *     color: '#999',
+   *   });
+   * });
+   * ```
+   */
+  trackCoordinate(coordinate: Coordinate, options: TTrackCoordinateOptions): Coordinate[] | number | null;
+  /**
+   * Stops any active coordinate tracking (tethering or travelled path visualization).
+   * @experimental
+   */
+  stopTracking(): void;
+  /**
+   * Returns the current tracking mode, or `null` if no tracking is active.
+   *
+   * - `'tethered'` — coordinate is being snapped onto the active path.
+   * - `'travelled'` — the traversed portion of the path is being recoloured.
+   *
+   * The mode is set as soon as {@link trackCoordinate} is called (even before
+   * the first coordinate is matched). For a stricter "is the visualisation
+   * currently active" check, use {@link isTracking}.
+   *
+   * @experimental
+   */
+  get currentTrackingMode(): 'tethered' | 'travelled' | null;
+  /**
+   * Returns true while a coordinate is actively being tracked and visualized
+   * on the path.
+   *
+   * - In `'tethered'` mode this is true whenever a tethered path is drawn or
+   *   path segments behind the user have been hidden.
+   * - In `'travelled'` mode this is true once one or more segments have been
+   *   marked as travelled.
+   *
+   * This is more precise than checking {@link currentTrackingMode}: the mode
+   * is set as soon as {@link trackCoordinate} is called, but `isTracking`
+   * only becomes true once the coordinate is successfully matched to the
+   * path. It also becomes false again if `coordinateOutsideThresholdMode` is
+   * `'untether'` and a coordinate falls outside the threshold.
+   *
+   * @experimental
+   */
+  get isTracking(): boolean;
+  /**
+   * Returns true while the dashed connector line from the tracked coordinate
+   * to the path is being drawn. This only happens in `'tethered'` mode when
+   * the coordinate is outside the tether threshold and
+   * `coordinateOutsideThresholdMode` is `'tether-and-dash'` (the default).
+   *
+   * @experimental
+   */
+  get isShowingOutsideThresholdPath(): boolean;
+  /**
+   * Returns the fraction (0–1) of the active path that has been travelled
+   * while in `'travelled'` mode. Returns `null` when not currently tracking
+   * in travelled mode.
+   *
+   * Multiply by {@link Navigation.activePath}'s `distance` to get the
+   * travelled distance in meters.
+   *
+   * In multi-destination mode this reflects progress along the currently
+   * active destination's path only — it resets when the active path
+   * changes.
+   *
+   * @experimental
+   */
+  get travelledFraction(): number | null;
   /**
    * Highlights path section between two coordinates. This can be used to highlight any section of the path or indicated the currently traveled path.
    */
@@ -4676,6 +4990,7 @@ declare class Footprint {
   private ceilingId?;
   private ceilingMaskId?;
   private basementMaskId?;
+  private extrudedPolygonId?;
   private footprintColor;
   layer: EntityId<GroupContainerState>;
   groupContainer: EntityId<GroupContainerState>;
@@ -4703,6 +5018,23 @@ declare class Footprint {
    * @param voidPolygons Array of polygon features representing voids
    */
   buildVoidWalls(voidPolygons: Feature$1<Polygon$1, any>[]): void;
+  /**
+   * Builds the footprint as a single extruded polygon (no separate walls or ceiling).
+   *
+   * Used as the "simple mode" alternative to `buildWalls` + `buildVoidWalls` + `buildCeiling`
+   * when no ceiling cuts are needed (i.e. `spacesOpenToBelowEnabled` is false, or it is
+   * enabled but neither this floor nor the floor above contributes any cuts). Collapses
+   * three feature collections into one, reducing draw calls per floor.
+   *
+   * The extruded mesh's top face acts as the "ceiling" — there is no separate ceiling
+   * layer, so `ceilingVisible` and `ceilingThickness` are not honoured in simple mode.
+   *
+   * Holes are stripped from the source geometry before extrusion. The footprint may carry
+   * void holes from MVF data, but in simple mode the user has opted out of "spaces open to
+   * below" (or there are no cuts to apply), so the top and bottom faces must be solid —
+   * matching the legacy `buildCeiling` path which also calls `removeHoles` before rendering.
+   */
+  buildExtrudedPolygon(): void;
   /**
    * Builds the ceiling with voids from the floor above
    */
@@ -4710,7 +5042,7 @@ declare class Footprint {
   /**
    * Builds the basement mask for elevation 0 floors
    */
-  buildBasementMask(): void;
+  buildBasementMask(spacesOpenToBelow?: Feature$1<Polygon$1, SpaceProperties>[]): void;
   /**
    * Updates the state of the footprint geometry (walls and ceiling)
    * @param state Partial state to update
@@ -4803,6 +5135,7 @@ declare class FloorObject implements FloorProperties {
   get visible(): boolean;
   setVisible(visible: boolean): void;
   buildCeiling(ceilingCuts: Feature$1<Polygon$1, any>[]): void;
+  buildExtrudedPolygon(): void;
   buildBasementMask(): void;
   /**
    * Builds a gap footprint representing missing floors below this floor.
@@ -5125,6 +5458,7 @@ declare class Shapes {
    * ```ts
    * const shape = mapView.Shapes.add(geometry, {
    *   color: 'green',
+   *   hoverColor: 'blue',
    *   opacity: 0.7,
    *   height: 2,
    *   interactive: true
@@ -5162,6 +5496,11 @@ type InspectorState = {
 type InspectorOption = Partial<InspectorState>;
 //#endregion
 //#region src/debug.d.ts
+/**
+ * Diagnostic utilities exposed at `MapView.Debug`. Provides toggles for
+ * debug visualizations, snapshots of the current camera state, and other
+ * inspection helpers useful while developing against Mappedin JS.
+ */
 declare class Debug {
   #private;
   state: DebugState$1;
@@ -6083,6 +6422,10 @@ type PartialExcept<T$1, K$1 extends string> = { [P in keyof T$1 as P extends K$1
 type ExtractDeep<T$1, U$1, Depth extends readonly number[] = []> = Depth['length'] extends 3 ? any : { [K in keyof T$1 as T$1[K] extends U$1 ? K : T$1[K] extends object | undefined ? ExtractDeep<NonNullable<T$1[K]>, U$1, [...Depth, 0]> extends never ? never : K : never]: T$1[K] extends object | undefined ? undefined extends T$1[K] ? ExtractDeep<NonNullable<T$1[K]>, U$1, [...Depth, 0]> | undefined : ExtractDeep<NonNullable<T$1[K]>, U$1, [...Depth, 0]> : T$1[K] extends U$1 ? T$1[K] : never };
 //#endregion
 //#region src/api-geojson/auto/index.d.ts
+/**
+ * Map view objects automatically created by `MapView.auto()` — typically labels
+ * and markers generated from venue data for common element types.
+ */
 type AutoElements = {
   labels: Label[];
   markers: Marker[];
@@ -6919,6 +7262,11 @@ declare class MapView {
   /**
    * Get the X and Y of a {@link Coordinate} measured from the top left corner of the map canvas.
    *
+   * The projected altitude is derived from the floor's live state (via `coordinate.floorId`)
+   * plus `coordinate.verticalOffset`. For coordinates without a `floorId`, `verticalOffset`
+   * is used directly as an absolute scene altitude — useful for "what if" projections at
+   * arbitrary altitudes without mutating the scene.
+   *
    * @experimental
    */
   getScreenCoordinateFromCoordinate(coordinate: Coordinate): {
@@ -7285,7 +7633,7 @@ declare class Camera {
   /**
    * The camera's current pan mode.
    */
-  get panMode(): "elevation" | "default";
+  get panMode(): "default" | "elevation";
   /**
    * Set the camera's pan mode. 'elevation' moves the camera up and down, while 'default' allows the camera to pan in all directions.
    * @experimental
@@ -7427,6 +7775,24 @@ declare class Camera {
    * The current elevation of the camera in meters.
    */
   get elevation(): number;
+  /**
+   * The maximum elevation (in meters) the camera is allowed to reach.
+   * @default Infinity
+   */
+  get maxElevation(): number;
+  /**
+   * Cap the camera's elevation in meters. Useful when `panMode` is
+   * `'elevation'` (vertical drag) to prevent the camera from rising above a
+   * building or floor stack. Pass `Infinity` to remove the cap.
+   *
+   * Applies to user pedestal drag, `setElevation`, and `animateElevation`.
+   * If the current elevation is above the new cap it is snapped down to it.
+   *
+   * @experimental
+   * @param maxElevation The new maximum elevation in meters.
+   * @default Infinity
+   */
+  setMaxElevation(maxElevation: number): void;
   /**
    * Animate the camera's elevation to a specified elevation.
    * @experimental
@@ -8182,6 +8548,11 @@ declare class Paths {
 type CurrentMapGetter$2 = () => GeojsonApiMapObject | undefined;
 //#endregion
 //#region src/api-geojson/style.d.ts
+/**
+ * Applies named visual style presets to the current map. Accessible from
+ * {@link MapView.Style}, it supports loading a {@link StyleCollection} or
+ * setting an individual style by id.
+ */
 declare class Style {
   #private;
   /**
@@ -8209,9 +8580,11 @@ type HiddenOutdoorGeometry = [polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSO
  * [MapLibre GL JS](https://maplibre.org/maplibre-gl-js/docs/) is a TypeScript library that uses WebGL to render interactive maps from vector tiles in a browser. The Mappedin SDK makes use of it to display the outdoor map.
  *
  * By providing access to the MapLibre map used to draw the outdoor map, the Mappedin SDK enables developers to draw on and manipulate the outdoor map.
- * Developers can use most capabilities of MapLibre GL JS with key exceptions being Interactivity and Camera, which are not available.
+ * Developers can use most capabilities of MapLibre GL JS. The key exception is Interactivity, which is not available; direct Camera control is discouraged because Mappedin JS owns the outdoor camera (see below).
+ *
+ * User touch and click events are handled by Mappedin JS and are not propagated to the outdoor map layer. Camera movement is also driven by Mappedin JS; moving the MapLibre camera directly is not supported and may be overridden.
  *
- * User touch and click events are handled by Mappedin JS and are not propagated to the outdoor map layer. Camera movement is also handled by Mappedin JS and cannot be manipulated using MapLibre controls.
+ * IMPORTANT: Moving the camera via `Outdoor.map` (for example `Outdoor.map.flyTo` / `easeTo` / `jumpTo` / `setZoom`) is not supported — Mappedin JS controls the outdoor camera and may override these calls. Use {@link MapView.Camera} (for example {@link Camera.animateTo}, {@link Camera.set}, or {@link Camera.focusOn}) instead.
  *
  * Refer to the [Outdoor Map Guide](https://developer.mappedin.com/web-sdk/outdoor-map) for more information and interactive examples.
  */
@@ -8227,11 +8600,30 @@ declare class Outdoor {
    */
   setStyle(style: any): void;
   /**
-   * Returns a Maplibre map for advanced usage.
+   * Returns the underlying MapLibre GL map for **advanced, non-camera** usage,
+   * such as adding custom layers, sources, GeoJSON, or deck.gl overlays.
+   *
+   * IMPORTANT: Moving the camera through this object is not supported. Camera
+   * control (center, zoom, bearing, pitch, elevation) is owned by Mappedin JS,
+   * so MapLibre camera methods such as `flyTo`, `easeTo`, `jumpTo`, `panTo`,
+   * `zoomTo`, `setZoom`, `setCenter`, `setBearing`, or `setPitch` may be
+   * overridden. Use the {@link Camera} API instead — it is the supported,
+   * fully-featured path (animation promises, collision-aware framing).
    *
-   * @returns {object} Maplibre map instance
+   * To move the camera, use the {@link Camera} API instead:
+   * - {@link Camera.animateTo} — smoothly move to a center / zoom / bearing / pitch
+   * - {@link Camera.set} — instantly set the camera
+   * - {@link Camera.focusOn} — frame one or more map elements
+   *
+   * @example Move the camera to a coordinate (correct — do NOT use `Outdoor.map.flyTo`)
+   * ```ts
+   * mapView.Camera.animateTo({ center: coordinate, zoomLevel: 19 }, { duration: 600 });
+   * ```
+   *
+   * @returns The MapLibre GL `Map` instance, or `undefined` if the outdoor view is disabled.
    *
    * Limitations:
+   * - Camera methods are not supported (see above) — use {@link MapView.Camera} to move the camera.
    * - Maplibre interaction events are not supported, use Mappedin JS interaction events.
    * - Maplibre markers and labels may overlap as they are not integrated with the Mappedin JS collision engine.
    */
@@ -8452,6 +8844,7 @@ declare class Text3D {
 }
 //#endregion
 //#region src/states/doors-state.d.ts
+/** @internal */
 declare const doorsStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"doors">>>;
   color: ZodOptional<ZodDefault<ZodString>>;
@@ -8465,6 +8858,7 @@ declare const doorsStateSchemaPartial: ZodObject<{
   visible: ZodOptional<ZodDefault<ZodBoolean>>;
   opacity: ZodOptional<ZodDefault<ZodNumber>>;
 }, $strip>;
+/** @internal */
 declare const doorsStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"doors">>;
   color: ZodDefault<ZodString>;
@@ -8478,24 +8872,39 @@ declare const doorsStateSchemaStrict: ZodObject<{
   visible: ZodDefault<ZodBoolean>;
   opacity: ZodDefault<ZodNumber>;
 }, $strict>;
+/**
+ * The serialized state of all doors in the map, including their colors and visibility.
+ */
 type TDoorsState = output<typeof doorsStateSchemaStrict>;
+/**
+ * A partial doors state used to apply incremental updates, where every field is optional.
+ */
 type TDoorsUpdateState = output<typeof doorsStateSchemaPartial>;
 //#endregion
 //#region src/states/facade-state.d.ts
+/** @internal */
 declare const facadeStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"facade">>>;
   opacity: ZodOptional<ZodDefault<ZodNumber>>;
   visible: ZodOptional<ZodDefault<ZodBoolean>>;
 }, $strip>;
+/** @internal */
 declare const facadeStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"facade">>;
   opacity: ZodDefault<ZodNumber>;
   visible: ZodDefault<ZodBoolean>;
 }, $strict>;
+/**
+ * The serialized state of all building facades, including their materials and visibility.
+ */
 type TFacadeState = output<typeof facadeStateSchemaStrict>;
+/**
+ * A partial facades state used to apply incremental updates, where every field is optional.
+ */
 type TFacadeUpdateState = output<typeof facadeStateSchemaPartial>;
 //#endregion
 //#region src/states/floor-state.d.ts
+/** @internal */
 declare const floorStateSchemaPartial: ZodObject<{
   geometry: ZodOptional<ZodObject<{
     type: ZodOptional<ZodDefault<ZodLiteral<"floor.geometry">>>;
@@ -8573,6 +8982,7 @@ declare const floorStateSchemaPartial: ZodObject<{
   visible: ZodOptional<ZodDefault<ZodBoolean>>;
   altitude: ZodOptional<ZodDefault<ZodNumber>>;
 }, $strip>;
+/** @internal */
 declare const floorStateSchemaStrict: ZodObject<{
   geometry: ZodObject<{
     type: ZodDefault<ZodLiteral<"floor.geometry">>;
@@ -8650,10 +9060,17 @@ declare const floorStateSchemaStrict: ZodObject<{
   visible: ZodDefault<ZodBoolean>;
   altitude: ZodDefault<ZodNumber>;
 }, $strict>;
+/**
+ * The serialized state of a floor, including its geometry, labels, markers, paths, and visibility.
+ */
 type TFloorState = output<typeof floorStateSchemaStrict>;
+/**
+ * A partial floor state used to apply incremental updates, where every field is optional.
+ */
 type TFloorUpdateState = output<typeof floorStateSchemaPartial>;
 //#endregion
 //#region src/states/geometry-state.d.ts
+/** @internal */
 declare const geometryStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"geometry">>>;
   visible: ZodOptional<ZodDefault<ZodBoolean>>;
@@ -8676,6 +9093,7 @@ declare const geometryStateSchemaPartial: ZodObject<{
   borderColor: ZodOptional<ZodOptional<ZodString>>;
   borderWidth: ZodOptional<ZodOptional<ZodNumber>>;
 }, $strip>;
+/** @internal */
 declare const geometryStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"geometry">>;
   visible: ZodDefault<ZodBoolean>;
@@ -8699,16 +9117,21 @@ declare const geometryStateSchemaStrict: ZodObject<{
   borderWidth: ZodOptional<ZodNumber>;
 }, $strict>;
 /**
- * Defines the state for geometry elements like {@link Space} when updated.
+ * The serialized state of a geometry element such as a {@link Space}, including
+ * its style, color, and visibility.
  */
 type TGeometryState = output<typeof geometryStateSchemaStrict>;
+/**
+ * A partial geometry state used to apply incremental updates, where every field is optional.
+ */
 type TGeometryUpdateState = output<typeof geometryStateSchemaPartial>;
 //#endregion
 //#region src/states/label-state.d.ts
+/** @internal */
 declare const labelStateSchema: ZodObject<{
   type: ZodDefault<ZodLiteral<"label">>;
   text: ZodString;
-  rank: ZodCustom<TCollisionRankingTier | "initial", TCollisionRankingTier | "initial">;
+  rank: ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>;
   appearance: ZodCustom<LabelAppearance, LabelAppearance>;
   interactive: ZodDefault<ZodBoolean>;
   enabled: ZodDefault<ZodBoolean>;
@@ -8727,10 +9150,11 @@ declare const labelStateSchema: ZodObject<{
   }>>]>>;
   occlude: ZodDefault<ZodBoolean>;
 }, $strip>;
+/** @internal */
 declare const labelStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"label">>>;
   text: ZodOptional<ZodString>;
-  rank: ZodOptional<ZodCustom<TCollisionRankingTier | "initial", TCollisionRankingTier | "initial">>;
+  rank: ZodOptional<ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>>;
   appearance: ZodOptional<ZodCustom<LabelAppearance, LabelAppearance>>;
   interactive: ZodOptional<ZodDefault<ZodBoolean>>;
   enabled: ZodOptional<ZodDefault<ZodBoolean>>;
@@ -8749,13 +9173,21 @@ declare const labelStateSchemaPartial: ZodObject<{
   }>>]>>>;
   occlude: ZodOptional<ZodDefault<ZodBoolean>>;
 }, $strip>;
+/**
+ * The serialized state of a label, including its position, appearance, and rank.
+ * Returned by state APIs and used by extensions that need to inspect or persist label state.
+ */
 type TLabelState = output<typeof labelStateSchema>;
+/**
+ * A partial label state used to apply incremental updates, where every field is optional.
+ */
 type TLabelUpdateState = output<typeof labelStateSchemaPartial>;
 //#endregion
 //#region src/states/marker-state.d.ts
+/** @internal */
 declare const markerStateSchema: ZodObject<{
   type: ZodDefault<ZodLiteral<"marker">>;
-  rank: ZodCustom<TCollisionRankingTier | "initial", TCollisionRankingTier | "initial">;
+  rank: ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>;
   placement: ZodOptional<ZodUnion<readonly [ZodEnum<{
     hidden: "hidden";
     top: "top";
@@ -8793,10 +9225,13 @@ declare const markerStateSchema: ZodObject<{
   occlude: ZodDefault<ZodBoolean>;
   animated: ZodDefault<ZodBoolean>;
 }, $strip>;
+/** @internal */
 declare const markerStateSchemaPartial: ZodObject<{
-  type: ZodOptional<ZodDefault<ZodLiteral<"marker">>>;
   enabled: ZodOptional<ZodDefault<ZodBoolean>>;
-  rank: ZodOptional<ZodCustom<TCollisionRankingTier | "initial", TCollisionRankingTier | "initial">>;
+  type: ZodOptional<ZodDefault<ZodLiteral<"marker">>>;
+  interactive: ZodOptional<ZodDefault<ZodUnion<readonly [ZodBoolean, ZodLiteral<"pointer-events-auto">]>>>;
+  rank: ZodOptional<ZodCustom<"initial" | TCollisionRankingTier, "initial" | TCollisionRankingTier>>;
+  occlude: ZodOptional<ZodDefault<ZodBoolean>>;
   placement: ZodOptional<ZodOptional<ZodUnion<readonly [ZodEnum<{
     hidden: "hidden";
     top: "top";
@@ -8820,7 +9255,6 @@ declare const markerStateSchemaPartial: ZodObject<{
     "bottom-left": "bottom-left";
     "bottom-right": "bottom-right";
   }>>]>>>;
-  interactive: ZodOptional<ZodDefault<ZodUnion<readonly [ZodBoolean, ZodLiteral<"pointer-events-auto">]>>>;
   dynamicResize: ZodOptional<ZodDefault<ZodBoolean>>;
   zIndex: ZodOptional<ZodOptional<ZodNumber>>;
   lowPriorityPin: ZodOptional<ZodOptional<ZodObject<{
@@ -8829,15 +9263,25 @@ declare const markerStateSchemaPartial: ZodObject<{
     color: ZodOptional<ZodString>;
   }, $strip>>>;
   contentHTML: ZodOptional<ZodString>;
-  occlude: ZodOptional<ZodDefault<ZodBoolean>>;
   animated: ZodOptional<ZodDefault<ZodBoolean>>;
 }, $strip>;
+/**
+ * The serialized state of a marker, including its anchor, HTML content, and rank.
+ * Returned by state APIs and used by extensions that need to inspect or persist marker state.
+ */
 type TMarkerState = output<typeof markerStateSchema>;
+/**
+ * A partial marker state used to apply incremental updates, where every field is optional.
+ */
 type TMarkerUpdateState = output<typeof markerStateSchemaPartial>;
 //#endregion
 //#region src/states/path-state.d.ts
-/** Border color - 'darken' auto-darkens main color, or explicit hex color string */
+/**
+ * Border color - 'darken' auto-darkens main color, or explicit hex color string.
+ * @internal
+ */
 type BorderColor = LiteralUnion<'darken', string>;
+/** @internal */
 declare const pathStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"path">>>;
   color: ZodOptional<ZodDefault<ZodString>>;
@@ -8851,6 +9295,8 @@ declare const pathStateSchemaPartial: ZodObject<{
   highlightWidthMultiplier: ZodOptional<ZodDefault<ZodNumber>>;
   highlightCompleteFraction: ZodOptional<ZodDefault<ZodNumber>>;
   xrayOpacity: ZodOptional<ZodDefault<ZodNumber>>;
+  travelledEndFraction: ZodOptional<ZodDefault<ZodNumber>>;
+  travelledColor: ZodOptional<ZodDefault<ZodString>>;
   __EXPERIMENTAL_SMOOTHING_TENSION: ZodOptional<ZodDefault<ZodNumber>>;
   __EXPERIMENTAL_SMOOTHING_CORNER_RADIUS: ZodOptional<ZodDefault<ZodNumber>>;
   dashed: ZodOptional<ZodDefault<ZodBoolean>>;
@@ -8886,6 +9332,7 @@ declare const pathStateSchemaPartial: ZodObject<{
     dithering: ZodOptional<ZodNumber>;
   }, $strip>>>;
 }, $strip>;
+/** @internal */
 declare const pathStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"path">>;
   color: ZodDefault<ZodString>;
@@ -8899,6 +9346,8 @@ declare const pathStateSchemaStrict: ZodObject<{
   highlightWidthMultiplier: ZodDefault<ZodNumber>;
   highlightCompleteFraction: ZodDefault<ZodNumber>;
   xrayOpacity: ZodDefault<ZodNumber>;
+  travelledEndFraction: ZodDefault<ZodNumber>;
+  travelledColor: ZodDefault<ZodString>;
   __EXPERIMENTAL_SMOOTHING_TENSION: ZodDefault<ZodNumber>;
   __EXPERIMENTAL_SMOOTHING_CORNER_RADIUS: ZodDefault<ZodNumber>;
   dashed: ZodDefault<ZodBoolean>;
@@ -8934,15 +9383,24 @@ declare const pathStateSchemaStrict: ZodObject<{
     dithering: ZodOptional<ZodNumber>;
   }, $strip>>;
 }, $strict>;
+/**
+ * The serialized state of a path, including its waypoints, style, and animation.
+ * Returned by state APIs and used by extensions that need to inspect or persist path state.
+ */
 type TPathState = output<typeof pathStateSchemaStrict>;
+/**
+ * A partial path state used to apply incremental updates, where every field is optional.
+ */
 type TPathUpdateState = input<typeof pathStateSchemaPartial>;
 //#endregion
 //#region src/states/shape-state.d.ts
+/** @internal */
 declare const shapeStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"shape">>>;
   visible: ZodOptional<ZodDefault<ZodBoolean>>;
   altitude: ZodOptional<ZodDefault<ZodNumber>>;
   color: ZodOptional<ZodDefault<ZodString>>;
+  hoverColor: ZodOptional<ZodOptional<ZodString>>;
   height: ZodOptional<ZodDefault<ZodNumber>>;
   opacity: ZodOptional<ZodDefault<ZodNumber>>;
   interactive: ZodOptional<ZodDefault<ZodBoolean>>;
@@ -8955,11 +9413,13 @@ declare const shapeStateSchemaPartial: ZodObject<{
   }, $strip>>>;
   position: ZodOptional<ZodCustom<Coordinate, Coordinate>>;
 }, $strip>;
+/** @internal */
 declare const shapeStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"shape">>;
   visible: ZodDefault<ZodBoolean>;
   altitude: ZodDefault<ZodNumber>;
   color: ZodDefault<ZodString>;
+  hoverColor: ZodOptional<ZodString>;
   height: ZodDefault<ZodNumber>;
   opacity: ZodDefault<ZodNumber>;
   interactive: ZodDefault<ZodBoolean>;
@@ -8973,12 +9433,16 @@ declare const shapeStateSchemaStrict: ZodObject<{
   position: ZodCustom<Coordinate, Coordinate>;
 }, $strict>;
 /**
- * Represents the state of a shape.
+ * The serialized state of a shape feature collection, including its geometry and styling.
  */
 type TShapeState = output<typeof shapeStateSchemaStrict>;
+/**
+ * A partial shape state used to apply incremental updates, where every field is optional.
+ */
 type TShapeUpdateState = output<typeof shapeStateSchemaPartial>;
 //#endregion
 //#region src/states/image-state.d.ts
+/** @internal */
 declare const imageStateSchema: ZodObject<{
   type: ZodDefault<ZodLiteral<"image3d">>;
   visible: ZodDefault<ZodBoolean>;
@@ -8989,7 +9453,9 @@ declare const imageStateSchema: ZodObject<{
   rotation: ZodDefault<ZodNumber>;
   verticalOffset: ZodDefault<ZodNumber>;
   flipImagesToFaceCamera: ZodDefault<ZodBoolean>;
+  interactive: ZodDefault<ZodBoolean>;
 }, $strip>;
+/** @internal */
 declare const imageStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"image3d">>>;
   visible: ZodOptional<ZodDefault<ZodBoolean>>;
@@ -9000,11 +9466,19 @@ declare const imageStateSchemaPartial: ZodObject<{
   rotation: ZodOptional<ZodDefault<ZodNumber>>;
   verticalOffset: ZodOptional<ZodDefault<ZodNumber>>;
   flipImagesToFaceCamera: ZodOptional<ZodDefault<ZodBoolean>>;
+  interactive: ZodOptional<ZodDefault<ZodBoolean>>;
 }, $strip>;
+/**
+ * The serialized state of a 3D image overlay, including its coordinate, size, and opacity.
+ */
 type TImage3DState = output<typeof imageStateSchema>;
+/**
+ * A partial 3D image state used to apply incremental updates, where every field is optional.
+ */
 type TImage3DUpdateState = output<typeof imageStateSchemaPartial>;
 //#endregion
 //#region src/states/model-state.d.ts
+/** @internal */
 declare const modelStateUpdateSchema: ZodObject<{
   altitude: ZodOptional<ZodOptional<ZodNumber>>;
   id: ZodOptional<ZodOptional<ZodUnion<readonly [ZodNumber, ZodString]>>>;
@@ -9024,6 +9498,7 @@ declare const modelStateUpdateSchema: ZodObject<{
   scale: ZodOptional<ZodUnion<readonly [ZodNumber, ZodTuple<[ZodNumber, ZodNumber, ZodNumber], null>]>>;
   rotation: ZodOptional<ZodUnion<readonly [ZodNumber, ZodTuple<[ZodNumber, ZodNumber, ZodNumber], null>]>>;
 }, $strip>;
+/** @internal */
 declare const modelStateSchemaStrict: ZodObject<{
   altitude: ZodOptional<ZodNumber>;
   id: ZodOptional<ZodUnion<readonly [ZodNumber, ZodString]>>;
@@ -9044,12 +9519,16 @@ declare const modelStateSchemaStrict: ZodObject<{
   clippingPlaneTopVisible: ZodDefault<ZodBoolean>;
 }, $strict>;
 /**
- * Represents the state of a model.
+ * The serialized state of a 3D model, including its coordinate, rotation, and scale.
  */
 type TModelState = output<typeof modelStateSchemaStrict>;
+/**
+ * A partial 3D model state used to apply incremental updates, where every field is optional.
+ */
 type TModelUpdateState = output<typeof modelStateUpdateSchema>;
 //#endregion
 //#region src/states/text3d-state.d.ts
+/** @internal */
 declare const text3DUpdateStateSchema: ZodObject<{
   visible: ZodOptional<ZodOptional<ZodBoolean>>;
   color: ZodOptional<ZodOptional<ZodString>>;
@@ -9070,6 +9549,7 @@ declare const text3DUpdateStateSchema: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"text3d">>>;
   position: ZodOptional<ZodCustom<Coordinate, Coordinate>>;
 }, $strict>;
+/** @internal */
 declare const text3DStateSchemaStrict: ZodObject<{
   visible: ZodBoolean;
   color: ZodString;
@@ -9096,10 +9576,17 @@ declare const text3DStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"text3d">>;
   position: ZodCustom<Coordinate, Coordinate>;
 }, $strict>;
+/**
+ * The serialized state of a 3D text element, including its coordinate, content, and appearance.
+ */
 type TText3DState = output<typeof text3DStateSchemaStrict>;
+/**
+ * A partial 3D text state used to apply incremental updates, where every field is optional.
+ */
 type TText3DUpdateState = output<typeof text3DUpdateStateSchema>;
 //#endregion
 //#region src/states/walls-state.d.ts
+/** @internal */
 declare const wallsStateSchemaPartial: ZodObject<{
   type: ZodOptional<ZodDefault<ZodLiteral<"walls">>>;
   color: ZodOptional<ZodDefault<ZodString>>;
@@ -9114,6 +9601,7 @@ declare const wallsStateSchemaPartial: ZodObject<{
   height: ZodOptional<ZodDefault<ZodNumber>>;
   opacity: ZodOptional<ZodDefault<ZodNumber>>;
 }, $strip>;
+/** @internal */
 declare const wallsStateSchemaStrict: ZodObject<{
   type: ZodDefault<ZodLiteral<"walls">>;
   color: ZodDefault<ZodString>;
@@ -9128,7 +9616,13 @@ declare const wallsStateSchemaStrict: ZodObject<{
   height: ZodDefault<ZodNumber>;
   opacity: ZodDefault<ZodNumber>;
 }, $strict>;
+/**
+ * The serialized state of all walls in the map, including their colors and visibility.
+ */
 type TWallsState = output<typeof wallsStateSchemaStrict>;
+/**
+ * A partial walls state used to apply incremental updates, where every field is optional.
+ */
 type TWallsUpdateState = output<typeof wallsStateSchemaPartial>;
 //#endregion
 //#region src/states/state-utils.d.ts
@@ -9601,7 +10095,7 @@ declare class Navigator {
   private geometryEdgesByMapId;
   private flagDeclarations;
   private getDoorByNodeId;
-  private disabledNodeIds;
+  private nonPublicNodeIds;
   /**
    * Constructs a Navigator instance to manage pathfinding with optional obstructions and grouping features.
    *
@@ -9626,7 +10120,11 @@ declare class Navigator {
     flagDeclarations?: NavigationFlagDeclarations;
     getDoorByNodeId: (nodeId: string) => DoorGeometry | undefined;
   });
-  private getDisabledNodeIds;
+  /**
+   * Build the set of node IDs that do not have the well-known `public` flag
+   * set. Returns an empty set when the MVF does not declare the flag.
+   */
+  private getNonPublicNodeIds;
   /**
    * Calculates and returns a set of directions from origin nodes to destination nodes, including detailed properties.
    *
@@ -9635,6 +10133,7 @@ declare class Navigator {
    * @param {string[]} destinationNodeIds - IDs of destination nodes.
    * @param {string[]} [disabledConnectionNodeIds] - IDs of connection nodes that are disabled (ie. act as regular nodes).
    * @param {SimplifyDirectionsOptions} [simplify] - Options to simplify the pathfinding result.
+   * @param {boolean} [includeNonPublic] - When true, nodes lacking the MVF `public` flag are routable. Defaults to false.
    * @returns {DirectionsCollection} A collection of directional features representing the path.
    */
   getDirections({
@@ -9646,7 +10145,8 @@ declare class Navigator {
     disabledConnectionNodeIds,
     simplify,
     multiplicativeDistanceWeightScaling,
-    overrideEdgeWeights
+    overrideEdgeWeights,
+    includeNonPublic
   }: {
     originIds: string[];
     destinationNodeIds: string[];
@@ -9657,6 +10157,7 @@ declare class Navigator {
     simplify?: SimplifyDirectionsOptions;
     multiplicativeDistanceWeightScaling?: boolean;
     overrideEdgeWeights?: Map<Edge, number>;
+    includeNonPublic?: boolean;
   }): DirectionsCollection;
   /**
    * Generates a path from a series of edges, constructing a feature collection of directional steps.
@@ -9838,6 +10339,7 @@ declare class DirectionsInternal {
     zones: TDirectionZone[];
     excludedConnections: Connection[];
     connectionIdWeightMap: Record<string, number>;
+    includeNonPublic: boolean;
   }, mapData: MapDataInternal) => Promise<Directions | undefined>;
   /** @deprecated use getDirections instead */
   getDirectionsSync: (from: TNavigationTarget[], to: TNavigationTarget[], options: {
@@ -9846,6 +10348,7 @@ declare class DirectionsInternal {
     zones: TDirectionZone[];
     excludedConnections: Connection[];
     connectionIdWeightMap: Record<string, number>;
+    includeNonPublic: boolean;
   }, mapData: MapDataInternal) => Directions | undefined;
   /**
    * Get the node IDs of connections that do not match the accessibility setting provided.
@@ -10023,6 +10526,11 @@ declare class MappedinRenderError extends MappedinError {
 }
 //#endregion
 //#region src/events.d.ts
+/**
+ * Free-form context string passed to `MapView.setFloor` (via {@link TSetFloorOptions})
+ * that is forwarded to `floor-change` event listeners as `event.reason`. Useful for
+ * distinguishing user-initiated floor changes from programmatic ones.
+ */
 type TFloorChangeReason = string;
 /**
  * The payload for a user click event on the map.
@@ -10061,6 +10569,10 @@ type TClickPayload = {
    * Interactive {@link Model}s under the pointer.
    */
   models?: Model[];
+  /**
+   * Interactive {@link Image3DView | 3D Image}s under the pointer.
+   */
+  images?: Image3DView[];
   /**
    * Interactive {@link Label}s under the pointer.
    */
@@ -10255,9 +10767,17 @@ type TEvents = {
     error: MappedinRenderError;
   };
 };
+/**
+ * Resolves to the payload type for a given {@link TEvents} event name. Use this
+ * to type the parameter of an event handler without depending on the internal
+ * shape of `TEvents`.
+ */
 type TEventPayload<EventName extends keyof TEvents> = TEvents[EventName] extends {
   data: null;
 } ? TEvents[EventName]['data'] : TEvents[EventName];
+/**
+ * Events emitted by {@link MapData}, such as when the active language pack changes.
+ */
 type TMapDataEvents = {
   'language-change': {
     code: string;
@@ -10299,12 +10819,22 @@ interface IGeoJSONData {
 }
 //#endregion
 //#region src/types/index.d.ts
+/**
+ * Result of an animation that may have run to completion or been cancelled before finishing.
+ */
 type TAnimateStateResult = {
   result: 'completed' | 'cancelled';
 };
+/**
+ * A promise extended with a `cancel()` method. Calling `cancel()` aborts the in-flight
+ * operation; the promise still settles, typically with a `'cancelled'` result.
+ */
 type TCancellablePromise<T$1> = Promise<T$1> & {
   cancel: () => void;
 };
+/**
+ * The action a user should take at a step of a {@link Directions} instruction.
+ */
 declare enum ACTION_TYPE {
   Departure = "Departure",
   TakeConnection = "TakeConnection",
@@ -10851,6 +11381,15 @@ type TGetDirectionsOptions = {
    * @default false
    */
   accessible?: boolean;
+  /**
+   * When true, routing may traverse nodes that do not have the MVF `public`
+   * flag set. Intended for emergency or staff-only pathing scenarios.
+   *
+   * Has no effect if the MVF does not declare a `public` navigation flag.
+   *
+   * @default false
+   */
+  includeNonPublic?: boolean;
   /**
    * Enable or disable path smoothing for directions.
    * When enabled, the path is simplified using line-of-sight checks to provide a more visually appealing route and shorter instructions.
@@ -11053,6 +11592,7 @@ type TAddModelOptions = Omit<InitializeModelState$1, 'scale' | 'url'> & {
   scale?: number | [number, number, number];
 };
 /**
+ * Options for adding a 3D text element to the map.
  * @interface
  */
 type TAddText3DOptions = AddText3DOptions$1;
@@ -11107,6 +11647,15 @@ type TAddImageOptions = {
    * @default 1024
    */
   maxImageSize?: number;
+  /**
+   * Whether the {@link Image3DView} should be clickable. When `true`, click and hover events
+   * for the image will be dispatched via `MapView.on('click')` and `MapView.on('hover')` under
+   * the `images` property of the event payload. Can be toggled at runtime via
+   * `MapView.updateState(image, { interactive })`.
+   *
+   * @default false
+   */
+  interactive?: boolean;
 };
 /**
  * Options for controlling the behavior of a {@link Marker}.
@@ -11200,7 +11749,7 @@ type TAddLabelOptions = {
   /**
    * Customize the appearance of the {@link Label} and its pin
    */
-  appearance?: LabelAppearance$1;
+  appearance?: LabelAppearance;
   /**
    * Whether the Label should be clickable.
    * @default false
@@ -11217,7 +11766,7 @@ type TAddLabelOptions = {
   /**
    * The placement of the text relative to the pin.
    */
-  textPlacement?: LabelTextPlacement$1[];
+  textPlacement?: LabelTextPlacement[];
   /**
    * Whether the label should be occluded by 3D geometry.
    * @default true
@@ -11245,6 +11794,11 @@ type WithState<T$1> = T$1 extends {
 type TUpdateState<T$1 extends MapElementsWithState | string> = T$1 extends {
   __type: infer U;
 } ? U extends keyof MapElementToUpdateState ? MapElementToUpdateState[U] : never : T$1 extends string ? T$1 extends keyof MapElementToUpdateState ? MapElementToUpdateState[T$1] : Record<string, any> : never;
+/**
+ * Maps each map element discriminator (`__type`) to the read-only rendered state
+ * type the element exposes. Used internally by `getRenderedState` to derive a
+ * precise return type from the element passed in.
+ */
 type MapElementToGetRenderedState = {
   [Label.__type]: ReadonlyDeep<LabelRenderedState>;
 };
@@ -11259,6 +11813,11 @@ type MapElementWithRenderedState = WithState<Label>;
 type TGetRenderedState<T$1 extends MapElementWithRenderedState | string> = T$1 extends {
   __type: infer U;
 } ? U extends keyof MapElementToGetRenderedState ? MapElementToGetRenderedState[U] : never : T$1 extends string ? T$1 extends keyof MapElementToGetRenderedState ? MapElementToGetRenderedState[T$1] : Record<string, any> : never;
+/**
+ * Map-wide state applied to all elements, such as the background color, hover
+ * highlight color, and shared visibility flags. Returned by `MapView.getState`
+ * and consumed by extensions that need a snapshot of the global render state.
+ */
 type GlobalState = {
   /**
    * The color of the background, in hex format(#000000).
@@ -11420,6 +11979,10 @@ type TCameraInteractionsSetOptions = {
    */
   bearingAndPitch?: boolean;
 };
+/**
+ * Options passed to `MapView.setFloor` to control how the floor change is performed
+ * and to provide an optional reason that is propagated to `floor-change` event listeners.
+ */
 type TSetFloorOptions = {
   /**
    * Optionally provide the context for the floor change which will be published as the `reason` for the `floor-change` event.
@@ -12147,6 +12710,12 @@ declare abstract class BaseMapData {
 }
 //#endregion
 //#region src/map-data-objects/detailed-map-data.d.ts
+/**
+ * Abstract base class for map data objects that carry rich metadata (images,
+ * hyperlinks, location profiles, and an external ID). Specific classes such as
+ * {@link Space}, {@link PointOfInterest}, and {@link Connection} extend this
+ * to expose typed accessors for their `details` payload.
+ */
 declare abstract class DetailedMapData<MVFData extends Feature$1<Geometry$1, {
   id: string;
   externalId?: string;
@@ -12276,8 +12845,8 @@ declare class Area extends DetailedMapData<AreaCollection['features'][number]> i
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
-    geometry: _mappedin_mvf_v28.Polygon;
+    type: _mappedin_mvf_v25.FeatureType;
+    geometry: _mappedin_mvf_v25.Polygon;
   };
   /** @internal */
   get focusTarget(): this;
@@ -12379,8 +12948,8 @@ declare class Door extends DetailedMapData<EntranceFeature> implements IGeoJSOND
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
-    geometry: _mappedin_mvf_v28.LineString;
+    type: _mappedin_mvf_v25.FeatureType;
+    geometry: _mappedin_mvf_v25.LineString;
   };
   /** @internal */
   get focusTarget(): Coordinate;
@@ -12516,8 +13085,8 @@ declare class Space extends DetailedMapData<SpaceFeature> implements IGeoJSONDat
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
-    geometry: _mappedin_mvf_v28.Point | _mappedin_mvf_v28.Polygon | _mappedin_mvf_v28.LineString;
+    type: _mappedin_mvf_v25.FeatureType;
+    geometry: _mappedin_mvf_v25.Point | _mappedin_mvf_v25.Polygon | _mappedin_mvf_v25.LineString;
   };
   /** @internal */
   get focusTarget(): this | Coordinate;
@@ -12603,7 +13172,7 @@ declare class PointOfInterest extends DetailedMapData<FeatureCollection$1<Point$
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
+    type: _mappedin_mvf_v25.FeatureType;
     geometry: Point$1;
   };
   /**
@@ -12717,8 +13286,8 @@ declare class Annotation extends DetailedMapData<AnnotationCollection['features'
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
-    geometry: _mappedin_mvf_v28.Point;
+    type: _mappedin_mvf_v25.FeatureType;
+    geometry: _mappedin_mvf_v25.Point;
   };
   /** @internal */
   get focusTarget(): Coordinate;
@@ -12934,8 +13503,8 @@ declare class MapObject extends DetailedMapData<ObstructionFeature> implements I
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
-    geometry: _mappedin_mvf_v28.Polygon | _mappedin_mvf_v28.LineString;
+    type: _mappedin_mvf_v25.FeatureType;
+    geometry: _mappedin_mvf_v25.Polygon | _mappedin_mvf_v25.LineString;
   };
   /** @internal */
   get anchorTarget(): Coordinate;
@@ -13248,8 +13817,8 @@ declare class Node extends BaseMetaData implements IGeoJSONData, IFocusable, IAn
    */
   get geoJSON(): {
     properties: null;
-    type: _mappedin_mvf_v28.FeatureType;
-    geometry: _mappedin_mvf_v28.Point;
+    type: _mappedin_mvf_v25.FeatureType;
+    geometry: _mappedin_mvf_v25.Point;
   };
   /** @internal */
   get focusTarget(): Coordinate;
@@ -14137,6 +14706,11 @@ declare class LocationCategory extends BaseMetaData implements Omit<Category, 'p
 }
 //#endregion
 //#region src/api-geojson/language.d.ts
+/**
+ * Options passed to {@link findPreferredLanguageInVenue} controlling which language is
+ * selected when more than one is available, and whether to fall back to the
+ * browser's preferred language.
+ */
 type TFindPreferredLanguageInVenueOptions = {
   /**
    * Preferred language code to use.
@@ -14492,6 +15066,10 @@ declare class InternalSearch {
   search(term: string, options?: SearchOptions): Promise<SearchResult>;
   suggest(term: string, options?: SuggestOptions): Promise<Suggestion[]>;
 }
+/**
+ * A single search result returned by `MapData.search`. Wraps the matched
+ * map data object along with its match metadata and relevance score.
+ */
 type SearchResultItem<T$1 extends Places | EnterpriseLocation | EnterpriseCategory> = {
   type: T$1['__type'];
   match: SearchResult$1['match'];
@@ -14499,14 +15077,17 @@ type SearchResultItem<T$1 extends Places | EnterpriseLocation | EnterpriseCatego
   item: T$1;
 };
 /**
+ * A search result wrapping a matched {@link EnterpriseCategory}.
  * @interface
  */
 type SearchResultEnterpriseCategory = SearchResultItem<EnterpriseCategory>;
 /**
+ * A search result wrapping a matched {@link EnterpriseLocation}.
  * @interface
  */
 type SearchResultEnterpriseLocations = SearchResultItem<EnterpriseLocation>;
 /**
+ * A search result wrapping a matched place (Space, PointOfInterest, etc.).
  * @interface
  */
 type SearchResultPlaces = SearchResultItem<Places>;
@@ -14561,6 +15142,8 @@ declare const suggestOptionsSchema: ZodObject<{
   }, $strip>>;
 }, $strip>;
 /**
+ * Options passed to `MapData.search` to filter the searchable data sources
+ * (places, enterprise locations, enterprise categories) and tune behavior.
  * @interface
  */
 type SearchOptions = output<typeof searchOptionsSchema>;
@@ -15285,7 +15868,7 @@ declare class MapData {
    * console.log(`Current language: ${language.name} (${language.code})`);
    * ```
    */
-  get currentLanguage(): _mappedin_mvf_v28.Language | undefined;
+  get currentLanguage(): _mappedin_mvf_v25.Language | undefined;
   /**
    * Gets the natural bearing of the map.
    *
@@ -15527,6 +16110,7 @@ type Style$1 = {
   join: LineStyle$2['join'];
   cap: LineStyle$2['cap'];
   topColor?: string;
+  hoverColor?: string;
   showImage: boolean;
   flipImageToFaceCamera: boolean;
   enableImageCollisions: boolean;
@@ -15898,42 +16482,92 @@ declare class Mask {
   dirty: boolean;
 }
 //#endregion
-//#region ../renderer-three/src/entities/batched-geometry-group.d.ts
+//#region ../renderer-three/src/entities/feature-collection.d.ts
 /**
- * State representing a Batched Geometry Group, which is a container for Geometries and Models
- * rendered via THREE.js BatchedMesh.
+ * State representing a Feature Collection, which is a conceptual container for
+ * GeoJSON features rendered via one or more THREE.js BatchedMeshes.
+ *
+ * Collection-level `visible` and `altitude` map directly to the wrapping
+ * `FeatureCollectionObject3D` (`.visible` and `.position.z`) and do not
+ * cascade into per-feature styles.
  */
-type BatchedGeometryGroupState = {
+type FeatureCollectionState = {
   readonly id: string | number;
-  readonly type: 'batched-geometry-group';
+  readonly type: 'feature-collection';
   /**
-   * The ids of the children of the geometry group
+   * The ids of the children of the feature collection
    */
   readonly children: (string | number)[];
   /**
-   * Whether the geometry group is visible
+   * @deprecated The feature collection no longer dictates opacity. Opacity is
+   * per-feature or controlled via the wrapping `GroupContainer`. Read-through
+   * to the first child is preserved for now.
    */
-  visible: boolean;
+  opacity?: number;
   /**
-   * Whether the geometry group is interactive, which means it can be hovered over and clicked on.
-   * This will affect all children of the geometry group and override their interactive state.
-   *
-   * @example
-   * ```javascript
-   * 	renderer.on('click', ({ geometry }) => {});
-   * ```
+   * @deprecated The feature collection no longer dictates color. Set color
+   * per-feature via the style callback. Read-through to the first child is
+   * preserved for now.
    */
-  interactive: boolean;
-  altitude?: number;
-  opacity?: number;
   color?: string;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   height?: number;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   texture?: string;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   topColor?: string;
+  /**
+   * Per-feature hover color. Setting this cascades to all children, and reads
+   * back through to the first child.
+   */
+  hoverColor?: string;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   topTexture?: string;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   outline?: boolean;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   shading?: Shading$1;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
   side?: MaterialSide;
+  /**
+   * @deprecated Per-feature property; read-through to the first child is
+   * preserved for now.
+   */
+  interactive?: boolean;
+  /**
+   * Collection-level visibility. Maps directly to `Object3D.visible` on the
+   * wrapping `FeatureCollectionObject3D`; toggling cascades to children via
+   * three.js's normal scene-graph traversal. Per-feature `StyleComponent.visible`
+   * is a separate axis controlled via `setState` on individual feature entities.
+   */
+  visible?: boolean;
+  /**
+   * Collection-level altitude. Maps directly to `position.z` on the wrapping
+   * `FeatureCollectionObject3D`. Per-feature altitude is a separate axis set
+   * via the style callback or on each child.
+   */
+  altitude?: number;
   /**
    * Bevel configuration for extruded shapes.
    */
@@ -15951,14 +16585,14 @@ type BatchedGeometryGroupState = {
   washOutAmount?: number;
   washOutUseDepth?: boolean;
   /**
-   * The position of the geometry group as a GeoJSON Position `[lon, lat]`.
-   * Always computable via centroid calculation. Vertical offset is managed by `altitude`.
+   * The position of the feature collection as a GeoJSON Position `[lon, lat]`,
+   * computed from the centroid of its child features. Vertical offset is a
+   * per-feature concern and is not tracked at the collection level.
    */
   position: Position$2;
 };
-declare class BatchedGeometryGroupObject3D extends Object3D {
-  visible: boolean;
-  readonly type: "batched-geometry-group";
+declare class FeatureCollectionObject3D extends Object3D {
+  readonly type: "feature-collection";
   components: [Mask?];
   getComponent(type: 'mask'): Mask | undefined;
   userData: {
@@ -15971,14 +16605,15 @@ declare class BatchedGeometryGroupObject3D extends Object3D {
     positionDirty: boolean;
     /** Cached world-space bounding-box center, updated after each position move */
     localCenter?: Vector3;
+    isMerged?: boolean;
   };
-  setVisible(visible: boolean): void;
   removeEntity(): void;
   constructor(id: string);
   /**
-   * Get first child entity of a group if it's a batched mesh.
-   * We use this logic a lot for getting the material of the group, since the group does not have
-   * a material and the batched mesh does.
+   * Get first child entity of a collection if it's a batched mesh.
+   * We use this logic for reading representative per-child state (e.g. color,
+   * texture) in getState() because the collection does not directly own a
+   * material; the batched mesh does.
    */
   getfirstChildEntityId(): string | number | undefined;
 }
@@ -16017,9 +16652,9 @@ declare class BatchedStandardMaterial extends MeshLambertMaterial {
   set blendTexture(value: boolean);
   setGradientShading(start: number, end: number, intensity: number): void;
   getGradientShading(): {
-    start: any;
-    end: any;
-    intensity: any;
+    start: number;
+    end: number;
+    intensity: number;
   };
   /**
    * Sets the distance-based effect parameters.
@@ -16069,6 +16704,62 @@ declare class BatchedStandardMaterial extends MeshLambertMaterial {
   clone(params?: MeshLambertMaterialParameters): this;
 }
 //#endregion
+//#region ../renderer-three/src/systems/batched-mesh/simple-material.d.ts
+/**
+ * Single-geometry variant of BatchedStandardMaterial.
+ * Uses `uColor`/`uTopColor` uniforms instead of a per-instance data texture,
+ * so no DataTexture is allocated. All gradient, shadow, and visual-effect
+ * uniforms are identical to BatchedStandardMaterial.
+ */
+declare class SimpleGeometryMaterial extends MeshLambertMaterial {
+  texturesVisible: boolean;
+  private pcfSampleCount;
+  private uniforms;
+  private colorSpace;
+  constructor(params?: MeshLambertMaterialParameters);
+  /**
+   * Sets `color` and `topColor` as uniforms directly (no batchId / data texture).
+   */
+  setColor(color: Color, topColor: Color): void;
+  getColor(): {
+    color: Color;
+    topColor: Color;
+  };
+  get texture(): Texture | null;
+  set texture(texture: Texture | null);
+  get topTexture(): Texture | null;
+  set topTexture(texture: Texture | null);
+  get blendTexture(): boolean;
+  set blendTexture(value: boolean);
+  setGradientShading(start: number, end: number, intensity: number): void;
+  getGradientShading(): {
+    start: number;
+    end: number;
+    intensity: number;
+  };
+  setEffectRange(start: number, distance: number): void;
+  getEffectRange(): {
+    start: number;
+    distance: number;
+  };
+  setVisualEffect(darkenAmount: number, darkenUseDepth: boolean, desaturateAmount: number, desaturateUseDepth: boolean, washOutAmount: number, washOutUseDepth: boolean): void;
+  getVisualEffect(): {
+    darkenAmount: number;
+    darkenUseDepth: number;
+    desaturateAmount: number;
+    desaturateUseDepth: number;
+    washOutAmount: number;
+    washOutUseDepth: number;
+  };
+  get repeatYFactor(): number;
+  set repeatYFactor(value: number);
+  showTextures: (_batchId: number) => void;
+  hideTextures(_batchId: number): void;
+  removeSideTexture(_batchId: number): void;
+  removeTopTexture(_batchId: number): void;
+  setShadowUniforms(shadowMap: Texture, lightMatrix: Matrix4, cameraNear: number, cameraFar: number, shadowBias: number, shadowOpacity: number, baseColor: Color, shadowMapSize: number, pcfSpread: number, pcfSamples: number, sunDir: Vector3, normalBias: number, depthRangeMax: number, shadowEnabled: boolean): void;
+}
+//#endregion
 //#region ../renderer-three/src/components/image.d.ts
 declare class EntityMesh$1 extends Mesh {
   userData: {
@@ -16090,6 +16781,11 @@ type ImageStyle = {
    * @default 1024
    */
   maxImageSize?: number;
+  /**
+   * Whether the image is interactive (receives click/hover events).
+   * @default false
+   */
+  interactive?: boolean;
 };
 type ImageProperties = {
   width: number;
@@ -16126,6 +16822,10 @@ type ImageState = {
    * The opacity of the image
    */
   opacity: number;
+  /**
+   * Whether the image is interactive (receives click/hover events).
+   */
+  interactive: boolean;
 };
 declare class ImageComponent {
   mesh: Geometry3DObject3D;
@@ -16152,6 +16852,9 @@ declare class EntityBatchedMesh extends BatchedMesh {
     detached?: boolean;
   };
 }
+declare class EntityMergedMesh extends Mesh {
+  type: "entityMergedMesh";
+}
 type MeshComponentProperties = {
   id: string;
   image?: ImageProperties & {
@@ -16177,7 +16880,7 @@ type GeometryState = {
   /**
    * The parent group of the geometry
    */
-  readonly parent: EntityId$1<BatchedGeometryGroupState>;
+  readonly parent: EntityId$1<FeatureCollectionState>;
   /**
    * Whether the geometry is visible. This is independent of the visibility of the children, but will affect the visibility of the children if set to false.
    */
@@ -16289,7 +16992,7 @@ type GeometryState = {
 };
 declare class MeshComponent {
   #private;
-  mesh?: EntityBatchedMesh;
+  mesh?: EntityBatchedMesh | EntityMergedMesh;
   imageMesh?: Mesh;
   /**
    * holds a pointer to space label text if the polygon has label active.
@@ -16307,10 +17010,10 @@ declare class MeshComponent {
     positionCount: number;
     geometryId: number;
   };
-  material?: BatchedStandardMaterial;
-  feature: Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties>;
+  material?: BatchedStandardMaterial | SimpleGeometryMaterial;
+  feature: Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties> | Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties>[];
   currentHeight: number;
-  constructor(feature: Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties>);
+  constructor(feature: Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties> | Feature<Polygon | LineString | MultiPolygon | MultiLineString, MeshComponentProperties>[]);
   get visible(): boolean;
   set visible(visible: boolean);
   get renderOrder(): number;
@@ -16339,7 +17042,7 @@ type ModelState = {
   /**
    * The parent container of the marker
    */
-  readonly parent?: EntityId$1<BatchedGeometryGroupState> | string | number;
+  readonly parent?: EntityId$1<FeatureCollectionState> | string | number;
   /**
    * The position of the model in [lon, lat]
    */
@@ -16512,6 +17215,17 @@ type PathState$1 = {
    * Configuration for x-ray appearance when path is behind geometry.
    */
   xrayStyle?: XrayStyleConfig;
+  /**
+   * The fraction of the path that has been travelled. This is used to indicate how far the user has walked along the path.
+   * Note: use values between 0 and 1.
+   * @default 0
+   */
+  travelledEndFraction: number;
+  /**
+   * The color of the travelled portion of the path.
+   * @default '#999'
+   */
+  travelledColor: string;
   /**
    * Controls the smoothness of path corners using CatmullRom curve tension. Higher values create smoother curves.
    * Values between 0.1-0.3 provide subtle smoothing suitable for most use cases.
@@ -16662,6 +17376,17 @@ type AddPathOptions = {
    * Configuration for x-ray appearance when path is behind geometry.
    */
   xrayStyle?: XrayStyleConfig;
+  /**
+   * The fraction of the path that has been travelled. This is used to indicate how far the user has walked along the path.
+   * Note: use values between 0 and 1.
+   * @default 0
+   */
+  travelledEndFraction?: number;
+  /**
+   * The color of the travelled portion of the path.
+   * @default '#999'
+   */
+  travelledColor?: string;
   /**
    * Controls the smoothness of path corners using CatmullRom curve tension. Higher values create smoother curves.
    * Values between 0.1-0.3 provide subtle smoothing suitable for most use cases.
@@ -16780,6 +17505,8 @@ declare class PathComponent {
   highlightColor: string;
   xrayOpacity: number;
   xrayStyle?: XrayStyleConfig;
+  travelledEndFraction: number;
+  travelledColor: string;
   dashed: boolean;
   smoothingTension: number;
   smoothingCornerRadius: number;
@@ -16920,6 +17647,9 @@ type Text3DState$1 = {
   readonly rotation: number;
 } & Text3DStyle;
 /**
+ * Initial state for a 3D text element when it is first added to the map.
+ * Mirrors the shape of {@link TText3DState} with all fields optional and
+ * with the auto-managed `id` and `type` fields omitted.
  * @interface
  */
 type InitializeText3DState$1 = Partial<Omit<Text3DState$1, 'id' | 'type'>>;
@@ -16934,7 +17664,7 @@ type Text3DProperties = {
   textArea?: MeshComponentProperties['textArea'];
 };
 /**
- * Options for labeling a geometry with 3D text.
+ * Options accepted when adding a 3D text element (for example to label a space).
  */
 type AddText3DOptions$2 = {
   appearance?: Partial<InitializeText3DState$1>;
@@ -17076,9 +17806,26 @@ type ClippingPlane = {
   verticalOffset: number;
   plane?: Plane;
   holeFillMesh?: Mesh;
+  /**
+   * Group containing the two stencil counting passes (mesh0/mesh1) that toggle
+   * the clipping bit on cross-section pixels. Must be kept in sync with the
+   * cap's visibility: when the cap isn't rendered, it can't clear the clipping
+   * bit, so the counting passes must also be skipped to avoid leaving the bit
+   * set and corrupting other stencil-based features (e.g. underground mask).
+   */
+  holeFillGroup?: Group$1;
   topColor?: string;
   needsRebuild: boolean;
   topVisible?: boolean;
+  /**
+   * World-space XY center of the model's bounding box. Used to size and position
+   * the stencil bias / hole-fill plane to the model's footprint instead of a
+   * giant screen-covering quad (which would corrupt other stencil features).
+   */
+  bboxCenter?: {
+    x: number;
+    y: number;
+  };
 };
 declare class ClippingPlaneComponent implements ClippingPlane {
   readonly type: "clippingPlane";
@@ -17087,8 +17834,13 @@ declare class ClippingPlaneComponent implements ClippingPlane {
   verticalOffset: number;
   plane?: Plane;
   holeFillMesh?: Mesh;
+  holeFillGroup?: Group$1;
   topColor?: string;
   topVisible: boolean;
+  bboxCenter?: {
+    x: number;
+    y: number;
+  };
 }
 //#endregion
 //#region ../renderer-three/src/entities/geometry3d.d.ts
@@ -17148,7 +17900,7 @@ declare class Geometry3D<M$1 extends MeshComponentTypes = MeshComponent, S exten
    */
   parentId?: string | number;
   get object3d(): M$1["mesh"];
-  get parentObject3D(): GroupContainerObject3D | BatchedGeometryGroupObject3D | null;
+  get parentObject3D(): GroupContainerObject3D | FeatureCollectionObject3D | null;
   type: T$1;
   entities2D: Map<string | number, Geometry2D>;
   constructor(meshComponent: M$1, styleComponent: S);
@@ -17269,6 +18021,14 @@ interface PathUniforms {
     type: 'f';
     value: number;
   };
+  travelledEndFraction: {
+    type: 'f';
+    value: number;
+  };
+  travelledColor: {
+    type: 'c';
+    value: Color;
+  };
   dashLength: {
     type: 'f';
     value: number;
@@ -17411,6 +18171,16 @@ declare class Renderer {
   setBackgroundColor(color: any, alpha: any): void;
   domElement(): HTMLCanvasElement | undefined;
   handleWebGLContextCreationError: (event: Event) => void;
+  /**
+   * The browser only fires the subsequent `webglcontextrestored` event if
+   * the page calls `preventDefault()` on the `webglcontextlost` event.
+   * Without this, after the GPU drops the context (e.g. iOS backgrounding,
+   * thermal pressure, or another canvas exhausting the per-process WebGL
+   * context budget), the canvas stays in a permanently lost state and any
+   * subsequent draws produce garbage geometry.
+   *
+   * See: https://registry.khronos.org/webgl/specs/latest/1.0/#5.15.2
+   */
   handleWebGLContextLost: (event: Event) => void;
   handleWebGLContextRestored: (event: Event) => void;
 }
@@ -17562,13 +18332,14 @@ declare class BatchedMeshSystem extends PubSub<{
   'geometry-2d-added': void;
   'geometry-group-added': void;
 }> {
+  #private;
   state: RendererState;
   convertTo3DMapPosition: any;
   constructor(state: RendererState, convertTo3DMapPosition: any);
-  createEntityFromFeature(id: string | number, feature: Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties>, style?: (LineStyle$2 | PaintStyle$2) & {
+  createEntityFromFeature(id: string | number, featureOrFeatures: Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties> | Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties>[], style?: (LineStyle$2 | PaintStyle$2) & {
     focusable?: boolean;
   }): Geometry3D<MeshComponent, StyleComponent, InteractionComponent, "geometry", OutlineComponent | undefined, FocusableComponent | undefined, TextureComponent | undefined, BorderComponent | undefined, ClippingPlaneComponent | undefined>;
-  populateEntityMesh(entity: Geometry3D, geometry: BufferGeometry): void;
+  populateEntityMesh(entity: Geometry3D, geometry: BufferGeometry, isMerged?: boolean): void;
   populateEntityGroup(entities: Set<string | number>): Set<string | number>;
   update(): Promise<void>;
 }
@@ -17909,6 +18680,7 @@ declare class CameraSystem extends PubSub<CameraEvents> {
   private cameraMoving;
   private lastCameraMoveTime;
   constructor(camera: PerspectiveCamera, scene: Scene, renderer: WebGLRenderer, rendererState: RendererState, options: CameraControlsOptions);
+  private addMovingStateListeners;
   /**
    * The amount the camera is shifted up/down
    * (corresponds to scroll amount in multifloor mode)
@@ -17986,6 +18758,25 @@ declare class CameraSystem extends PubSub<CameraEvents> {
    * @returns {Number} The time in ms the camera stopped moving.
    */
   lastCameraStoppedMovingTime: () => number;
+  /**
+   * Marks the camera as under active external manipulation (e.g. a Mapbox/MapLibre
+   * overlay gesture) and publishes `pan-start`. While in this state, the per-tick
+   * `*-start`/`*-end` publishes inside setters are gated off, so a burst of
+   * setCenter/setZoom/setRotation/setTilt calls does not flicker
+   * `cameraMoving` between true and false.
+   *
+   * @hidden
+   */
+  beginGesture: () => void;
+  /**
+   * Ends a gesture started by {@link beginGesture} and publishes `pan-end`.
+   * No-op if state is not PAN — guards against stomping a concurrent
+   * user-initiated drag, and against `moveend` firing without a matching
+   * `movestart`.
+   *
+   * @hidden
+   */
+  endGesture: () => void;
   /**
    * Sets the camera anchor to a specifc x/y positon, in the global reference frame. 0,0 will be roughly the middle of the map, and panBounds holds the min/max points.
    *
@@ -18376,6 +19167,21 @@ declare class Camera$2 extends PubSub<{
    * The camera's current elevation in meters from the ground.
    */
   get elevation(): number;
+  /**
+   * The maximum elevation (in meters) the camera is allowed to reach.
+   * @default Infinity
+   */
+  get maxElevation(): number;
+  /**
+   * Cap the camera's elevation in meters. Applies to user pedestal drag (when
+   * `panMode` is `'elevation'`), `setElevation`, and `animateElevation`. The
+   * current elevation is snapped down to the cap if it exceeds the new
+   * maximum.
+   *
+   * @param maxElevation The new maximum elevation in meters.
+   * @default Infinity
+   */
+  setMaxElevation(maxElevation: number): void;
   /**
    * @param elevation The elevation in meters.
    */
@@ -18704,7 +19510,7 @@ declare class OutlineInterpolationSystem extends PubSub<{
    * @param options - Optional configuration for outline rendering
    */
   constructor(rendererState: RendererState, options?: OutlinesOptions$1);
-  buildOutlines(geometryGroupEntity: BatchedGeometryGroupObject3D): void;
+  buildOutlines(geometryGroupEntity: FeatureCollectionObject3D): void;
   /**
    * Update the outline color of all entities with an outline component.
    * @param zoomLevel - The current zoom level.
@@ -19086,6 +19892,16 @@ declare class Debug$1 {
 }
 //#endregion
 //#region ../renderer-three/src/systems/2d-occlusion/system.d.ts
+/**
+ * Set to `true` by the visual regression harness (see `e2e/visual/fixtures.ts`)
+ * before page load. When set we bypass the throttle so screenshots are
+ * deterministic. Anything else leaves the throttle in effect.
+ */
+declare global {
+  interface Window {
+    __MAPPEDIN_E2E__?: boolean;
+  }
+}
 declare class Occlusion2DSystem {
   private state;
   private renderer;
@@ -19113,7 +19929,17 @@ declare class Occlusion2DSystem {
   resize: () => void;
   private shouldShowByXY;
   activeOccluders: Set<unknown>;
+  private framesSinceLastUpdate;
+  /**
+   * Throttled per-frame entry point called by the render loop. Delegates to
+   * {@link updateImmediately} once every {@link OCCLUSION_SKIP_FRAMES} calls.
+   * Callers that need a guaranteed synchronous pass should use
+   * {@link updateImmediately} directly. When running under the visual
+   * regression harness (`?e2e=true`) the throttle is bypassed so every
+   * render produces a deterministic occlusion state.
+   */
   update: () => void;
+  updateImmediately: () => void;
   destroy(): void;
 }
 //#endregion
@@ -19149,7 +19975,9 @@ declare class BorderSystem {
   convertTo3DMapPosition: Core['convertTo3DMapPosition'];
   constructor(rendererState: RendererState, convertTo3DMapPosition: Core['convertTo3DMapPosition']);
   update(): void;
+  private buildBordersForFeatures;
   private colorToMaterialCache;
+  private getOrCreateMaterials;
   private buildBorder;
   destroy(): void;
 }
@@ -19228,11 +20056,23 @@ declare class ClippingPlaneSystem {
   update(): void;
   private process;
   /**
-   * Creates the stencil geometry for hole fill detection
-   * @param modelGeometry - The merged model geometry for counting passes
-   * @param planeGeometry - The plane geometry for bias pass (covers entire hole fill area)
-   * @param plane - The clipping plane
-   * @param renderOrder - Base render order for the meshes
+   * Creates the stencil counting passes that mark cross-section pixels.
+   *
+   * Two passes operate on a single reserved stencil bit (CLIPPING_BIT = 0x80),
+   * which is guaranteed to be 0 in every mask ID, so the clipping system and the
+   * masking system never overwrite each other's stencil state:
+   *
+   *  - mesh0 (back faces below clip): toggles bit 7 via InvertStencilOp.
+   *  - mesh1 (front faces below clip): toggles bit 7 via InvertStencilOp.
+   *
+   * For closed manifold meshes from a camera outside the model, each balanced
+   * back/front pair toggles bit 7 twice (returning it to 0), while each unpaired
+   * back face above the clip leaves bit 7 = 1. The cap then renders where
+   * bit 7 == 1 and immediately clears bit 7 again with ZeroStencilOp.
+   *
+   * @param modelGeometry - The merged model geometry used for both passes
+   * @param plane - The user-defined clipping plane
+   * @param renderOrder - Base render order for the passes
    */
   private createHoleFillGeometry;
 }
@@ -19664,7 +20504,7 @@ declare class ModelSystem extends PubSub<{
    * @param tree - The geometry group container
    * @returns The created Object3D containing the model instances
    */
-  populateModelGroup(entities: Set<string | number>, url: string, tree: BatchedGeometryGroupObject3D): Promise<Geometry3DObject3D>;
+  populateModelGroup(entities: Set<string | number>, url: string, tree: FeatureCollectionObject3D): Promise<Geometry3DObject3D>;
   /**
    * Updates the model system, processing any pending model loads and style updates
    * @returns A promise that resolves when all model loading is complete
@@ -19866,6 +20706,10 @@ type Systems = {
   pluginSystem: PluginSystem;
   shadowsSystem?: ShadowsSystem;
 };
+/**
+ * Top-level state for the MapView, exposing global hover colors that apply
+ * to all interactive elements. Returned by state APIs and consumed by extensions.
+ */
 type MapViewState$1 = {
   readonly type: 'map-view';
   hoverColor: string;
@@ -19873,7 +20717,7 @@ type MapViewState$1 = {
 };
 declare class Core extends PubSub<MapEvent> {
   #private;
-  options: Omit<RendererCoreOptions$1, 'outdoorView'>;
+  options: Omit<RendererCoreOptions$2, 'outdoorView'>;
   container: HTMLElement;
   Debug: Debug$1;
   /**
@@ -19906,7 +20750,7 @@ declare class Core extends PubSub<MapEvent> {
   /**
    * @internal
    */
-  constructor(container: HTMLElement, options?: RendererCoreOptions$1);
+  constructor(container: HTMLElement, options?: RendererCoreOptions$2);
   /**
    * Projects a position into screen space. If a Vector3 is provided, the z-coordinate will include the depth from the camera.
    * @param projectVector - The vector to project the position into
@@ -19941,10 +20785,24 @@ declare class Core extends PubSub<MapEvent> {
   registerPlugin(plugin: ISystemPlugin$2): void;
   unregisterPlugin(plugin: ISystemPlugin$2): void;
   /**
-   * Add a batched geometry group from GeoJSON data.
-   * Features are batched into a single BatchedMesh per material group for efficient rendering.
+   * Add a conceptual feature collection from GeoJSON data.
+   *
+   * Each feature is converted into a batched entity, which may be split across
+   * multiple BatchedMeshes internally based on material. The collection itself
+   * is a lightweight container; visual properties such as color, opacity,
+   * altitude, height, etc. are driven per-feature via the `style` callback.
+   *
+   * To toggle visibility of the whole collection, wrap it in a
+   * `GroupContainer` via the `parent` argument and set visibility on the
+   * container.
+   *
+   * The only collection-level concern honored at creation time is the optional
+   * mask — read from `style(features[0])`.
    */
-  addBatchedGeometryGroup<T$1 extends FeatureCollection<Polygon | MultiPolygon | LineString, any>>(id: string, geometry: T$1, style?: (T$1 extends FeatureCollection<LineString, any> ? LineStyle$2 : PaintStyle$2) | ((feature: Feature<Polygon | MultiPolygon | LineString, any>) => T$1 extends FeatureCollection<LineString, any> ? LineStyle$2 : PaintStyle$2), parent?: EntityId$1<GroupContainerState$1> | string | number | null): EntityId$1<BatchedGeometryGroupState>;
+  addFeatureCollection<T$1 extends FeatureCollection<Polygon | MultiPolygon | LineString, any>>(id: string, geometry: T$1, style?: ((feature: Feature<Polygon | MultiPolygon | LineString, any>) => T$1 extends FeatureCollection<LineString, any> ? LineStyle$2 : PaintStyle$2) | (T$1 extends FeatureCollection<LineString, any> ? LineStyle$2 : PaintStyle$2), fcState?: {
+    altitude?: number;
+    visible?: boolean;
+  }, parent?: EntityId$1<GroupContainerState$1> | string | number | null): EntityId$1<FeatureCollectionState>;
   addOccluder<T$1 extends Feature<Polygon | MultiPolygon, any>>(feature: T$1, parent?: EntityId$1<GroupContainerState$1> | string | number | null): number;
   addImage(id: string, geometry: Feature<Point, ImageProperties>, style: ImageStyle, parent?: EntityId$1<GroupContainerState$1> | string | null): EntityId$1<ImageState> | undefined;
   /**
@@ -19956,7 +20814,7 @@ declare class Core extends PubSub<MapEvent> {
   }?: {
     parent?: EntityId$1<GroupContainerState$1> | string | null;
     onComplete?: () => void;
-  }): EntityId$1<BatchedGeometryGroupState> | undefined;
+  }): EntityId$1<FeatureCollectionState> | undefined;
   /**
    * Add an HTML Marker at a GeoJSON coordinate.
    */
@@ -20038,9 +20896,9 @@ declare class Core extends PubSub<MapEvent> {
    * Get the current state of the map view, or any entity that was added, regardless of whether it is visible in the scene
    */
   getState(): MapViewState$1;
-  getState<T$1 extends EntityId$1<EntityState>>(geometryOrGeometryId: T$1): T$1 extends EntityId$1<LabelState> ? LabelState : T$1 extends EntityId$1<GeometryState> ? GeometryState : T$1 extends EntityId$1<MarkerState$1> ? MarkerState$1 : T$1 extends EntityId$1<BatchedGeometryGroupState> ? BatchedGeometryGroupState : T$1 extends EntityId$1<GroupContainerState$1> ? GroupContainerState$1 : T$1 extends EntityId$1<ModelState> ? ModelState : T$1 extends EntityId$1<PathState$1> ? PathState$1 : T$1 extends EntityId$1<ShapeState> ? ShapeState : T$1 extends EntityId$1<ImageState> ? ImageState : T$1 extends EntityId$1<Text3DState$1> ? Text3DState$1 : EntityState;
+  getState<T$1 extends EntityId$1<EntityState>>(geometryOrGeometryId: T$1): T$1 extends EntityId$1<LabelState> ? LabelState : T$1 extends EntityId$1<GeometryState> ? GeometryState : T$1 extends EntityId$1<MarkerState$1> ? MarkerState$1 : T$1 extends EntityId$1<FeatureCollectionState> ? FeatureCollectionState : T$1 extends EntityId$1<GroupContainerState$1> ? GroupContainerState$1 : T$1 extends EntityId$1<ModelState> ? ModelState : T$1 extends EntityId$1<PathState$1> ? PathState$1 : T$1 extends EntityId$1<ShapeState> ? ShapeState : T$1 extends EntityId$1<ImageState> ? ImageState : T$1 extends EntityId$1<Text3DState$1> ? Text3DState$1 : EntityState;
   getState(geometryOrGeometryId?: Record<string | number, any> | string | number): EntityState;
-  getState<T$1 extends EntityState>(geometryOrGeometryId: T$1['id']): T$1 extends LabelState ? LabelState : T$1 extends GeometryState ? GeometryState : T$1 extends MarkerState$1 ? MarkerState$1 : T$1 extends BatchedGeometryGroupState ? BatchedGeometryGroupState : T$1 extends GroupContainerState$1 ? GroupContainerState$1 : T$1 extends ModelState ? ModelState : T$1 extends PathState$1 ? PathState$1 : T$1 extends ShapeState ? ShapeState : T$1 extends ImageState ? ImageState : EntityState;
+  getState<T$1 extends EntityState>(geometryOrGeometryId: T$1['id']): T$1 extends LabelState ? LabelState : T$1 extends GeometryState ? GeometryState : T$1 extends MarkerState$1 ? MarkerState$1 : T$1 extends FeatureCollectionState ? FeatureCollectionState : T$1 extends GroupContainerState$1 ? GroupContainerState$1 : T$1 extends ModelState ? ModelState : T$1 extends PathState$1 ? PathState$1 : T$1 extends ShapeState ? ShapeState : T$1 extends ImageState ? ImageState : EntityState;
   /**
    * Get rendered state for an entity (e.g., runtime rendering state that changes frequently)
    * @param entity The entity to get rendered state for
@@ -20053,7 +20911,7 @@ declare class Core extends PubSub<MapEvent> {
   setState(object: Partial<Omit<MapViewState$1, 'type'>>): void;
   setState<T$1 extends EntityId$1<LabelState>>(object: T$1 | T$1['id'], state: Partial<LabelState>): void;
   setState<T$1 extends EntityId$1<MarkerState$1>>(object: T$1 | T$1['id'], state: Partial<MarkerStateUpdate>): void;
-  setState<T$1 extends EntityId$1<BatchedGeometryGroupState>>(object: T$1 | T$1['id'], state: Partial<BatchedGeometryGroupState>): void;
+  setState<T$1 extends EntityId$1<FeatureCollectionState>>(object: T$1 | T$1['id'], state: Partial<FeatureCollectionState>): void;
   setState<T$1 extends EntityId$1<GroupContainerState$1>>(object: T$1 | T$1['id'], state: Partial<GroupContainerState$1>): void;
   setState<T$1 extends EntityId$1<GeometryState>>(object: T$1 | T$1['id'], state: Partial<GeometryState>): void;
   setState<T$1 extends EntityId$1<ShapeState>>(object: T$1 | T$1['id'], state: Partial<ShapeState>): void;
@@ -20239,7 +21097,7 @@ type GroupContainerState$1 = {
   /**
    * The states of the children of the group container
    */
-  readonly children: (PathState$1 | MarkerState$1 | LabelState | GroupContainerState$1 | BatchedGeometryGroupState)[];
+  readonly children: (PathState$1 | MarkerState$1 | LabelState | GroupContainerState$1 | FeatureCollectionState)[];
   /**
    * Whether the group container is visible
    */
@@ -20261,7 +21119,7 @@ type GroupContainerState$1 = {
 };
 declare class GroupContainerObject3D extends Object3D {
   childrenIds: Set<string | number>;
-  children: (GroupContainerObject3D | BatchedGeometryGroupObject3D | BatchedText$1 | Geometry2D['object3d'] | NonNullable<Geometry3D['object3d']>)[];
+  children: (GroupContainerObject3D | FeatureCollectionObject3D | BatchedText$1 | Geometry2D['object3d'] | NonNullable<Geometry3D['object3d']>)[];
   getComponent(): void;
   readonly type: "group-container";
   userData: {
@@ -20282,11 +21140,12 @@ declare class GroupContainerObject3D extends Object3D {
   components: [InteractionComponent?, FocusableComponent?];
   constructor(id: string);
   addOccluderFeature(feature: Feature<Polygon | MultiPolygon, any>, occluderId: number): void;
-  addEntity(entityGroupOrContainer: GroupContainerObject3D | BatchedGeometryGroupObject3D | Geometry2D | Geometry3DTypes): void;
+  addEntity(entityGroupOrContainer: GroupContainerObject3D | FeatureCollectionObject3D | Geometry2D | Geometry3DTypes): void;
   removeEntity(entityGroupOrContainer: EntityTypes): void;
   setVisible(visible: boolean): void;
   setAltitude(altitude: number): void;
   set2DGeometryChildrenPositionDirty(): void;
+  liftFocusableCaches(dz: number): void;
   get altitude(): number;
   setOpacity(opacity: number): void;
   get opacity(): number;
@@ -20323,7 +21182,7 @@ declare class Geometry2D {
   type: 'label' | 'marker';
   /** Lightweight entity for the 2D pipeline */
   entity2D: Entity2D;
-  get parentObject3D(): GroupContainerObject3D | BatchedGeometryGroupObject3D | null;
+  get parentObject3D(): GroupContainerObject3D | FeatureCollectionObject3D | null;
   /** The geometry3D that this 2D entity is attached to */
   get attachedTo(): string | number | undefined;
   verticalOffset: number;
@@ -20363,15 +21222,24 @@ declare class Geometry2D {
 type Position$2 = [lon: number, lat: number] | [lon: number, lat: number, alt: number];
 //#endregion
 //#region ../renderer-three/src/types/options.d.ts
+/**
+ * Selects which environment map is used for image-based lighting.
+ * `'basic'` enables a default environment map, `false` disables environment lighting.
+ */
 type EnvMapOptions$2 = 'basic' | false;
-type RendererCoreOptions$1 = Partial<{
+/**
+ * Low-level options consumed by `RendererCore` to configure rendering, camera
+ * defaults, outdoor view integration, and visual effects. Most consumers
+ * should use `TShow3DMapOptions` instead, which is converted into this shape internally.
+ */
+type RendererCoreOptions$2 = Partial<{
   center?: Position$2;
   zoomLevel?: number;
   pitch?: number;
   bearing?: number;
   naturalBearing?: number;
   outdoorView: {
-    headers: {
+    headers?: {
       'x-mappedin-tiles-key': string;
     };
     style?: string;
@@ -20524,7 +21392,7 @@ type ShadowsOptions = {
 /**
  * The state of an entity, which can be a geometry, geometry group, group container, path, model, label, or marker.
  */
-type EntityState = GeometryState | BatchedGeometryGroupState | GroupContainerState$1 | PathState$1 | ModelState | LabelState | MarkerState$1 | ImageState | Text3DState$1 | ShapeState;
+type EntityState = GeometryState | FeatureCollectionState | GroupContainerState$1 | PathState$1 | ModelState | LabelState | MarkerState$1 | ImageState | Text3DState$1 | ShapeState;
 /**
  * A wrapper object that contains the ID and type of an entity. This is returned when adding entities to the scene, and can be used
  * to `getState` and `setState` of the entity.
@@ -20567,9 +21435,14 @@ type BevelState = {
    */
   segments?: number;
 };
+/**
+ * Visual styling for filled (polygon-based) geometry such as spaces and shapes.
+ * Controls color, opacity, height, textures, bevel, shading and outlines.
+ */
 type PaintStyle$2 = {
   color: string;
   topColor?: string;
+  hoverColor?: string;
   height?: number;
   altitude?: number;
   opacity?: number;
@@ -20608,14 +21481,23 @@ type PaintStyle$2 = {
    */
   __EXPERIMENTAL_maskEnabled?: boolean;
 };
+/**
+ * Configures the vertical shading gradient applied to extruded geometry to give
+ * walls and shapes a sense of depth. `start` and `end` are normalized heights.
+ */
 type Shading$1 = {
   start?: number;
   end?: number;
   intensity?: number;
 };
+/**
+ * Visual styling for line-based geometry such as paths and connection lines.
+ * Controls color, width, caps/joins, shading and outlines.
+ */
 type LineStyle$2 = {
   color: string;
   topColor?: string;
+  hoverColor?: string;
   width: number;
   opacity?: number;
   height?: number;
@@ -20654,6 +21536,10 @@ type ModelProperties = {
    */
   visibleThroughGeometry?: boolean;
 };
+/**
+ * Padding applied to the camera's visible area so map content stays clear of
+ * UI overlays such as headers, sidebars and bottom sheets.
+ */
 type InsetPadding$2 = {
   top: number;
   left: number;
@@ -20696,6 +21582,11 @@ type ClickPayload = {
    * An array of 3D models IDs which the user interaction passed through. Will be empty if no models were interacted with.
    */
   models: [string | number] | [];
+  /**
+   * An array of 3D image IDs which the user interaction passed through. Will be empty if no images were interacted with.
+   * Only images added with `interactive: true` are included.
+   */
+  images: [string | number] | [];
   /**
    * An array of label IDs which the user interaction passed through. Will be empty if no labels were interacted with.
    */
@@ -20805,7 +21696,12 @@ type MapEvent = {
 /**
  * All entities in 3D
  */
-type All3DTypes = Geometry3DTypes | BatchedGeometryGroupObject3D | GroupContainerObject3D;
+type All3DTypes = Geometry3DTypes | FeatureCollectionObject3D | GroupContainerObject3D;
+/**
+ * Snapshot of the renderer's internal state passed to {@link ISystemPlugin}
+ * instances on every frame. Exposes the Three.js scene, camera and geometry
+ * registries so plugins can inspect or augment the render pipeline.
+ */
 type RendererState = {
   /**
    * A map of all 3D geometries in the world.
@@ -20836,7 +21732,7 @@ type RendererState = {
   /**
    * IDs of geometry groups that need to be loaded, including preloaded geometry groups that are not in the scene yet
    */
-  readonly geometryGroupIdsToLoad: Set<BatchedGeometryGroupObject3D['userData']['entityId']>;
+  readonly geometryGroupIdsToLoad: Set<FeatureCollectionObject3D['userData']['entityId']>;
   readonly geometryScene: GroupContainerObject3D;
   hoverColor: string;
   text3dHoverColor: string;
@@ -20876,7 +21772,7 @@ type RendererState = {
 /**
  * All of the entities in the scene
  */
-type EntityTypes = Geometry3DTypes | Geometry2D | BatchedGeometryGroupObject3D | GroupContainerObject3D;
+type EntityTypes = Geometry3DTypes | Geometry2D | FeatureCollectionObject3D | GroupContainerObject3D;
 /** @internal */
 type TransformImageRequest = (url: string) => Promise<{
   url: string;
@@ -21014,14 +21910,29 @@ declare class MapLibreOverlay<T$1> extends PubSub<T$1> implements IControl {
   origin?: Position$2;
   map?: Map$1;
   layer?: CustomLayerInterface;
-  constructor(origin: Position$2 | undefined, options?: RendererCoreOptions$1);
+  private cameraSystem;
+  constructor(origin: Position$2 | undefined, options?: RendererCoreOptions$2);
   private handleStyleChange;
+  private handleMoveStart;
   private handleMove;
+  private handleMoveEnd;
   private handleError;
+  /**
+   * Called by MapLibre when this overlay is added to a map as an IControl.
+   * @param map - The MapLibre map this overlay is being attached to.
+   * @returns The DOM element rendered by this overlay.
+   */
   onAdd(map: Map$1): HTMLDivElement;
+  /**
+   * Called by MapLibre when this overlay is removed from a map. Detaches all
+   * map listeners, removes the custom layer, and destroys the underlying renderer.
+   */
   onRemove(): void;
 }
 //#endregion
+//#region ../renderer-three/src/utils/constants.d.ts
+declare const MAPPEDIN_LAYER_ID = "mappedin";
+//#endregion
 //#region src/constants.d.ts
 declare const MAPPEDIN_COLORS: {
   orange: string;
@@ -21030,15 +21941,37 @@ declare const MAPPEDIN_COLORS: {
 };
 //#endregion
 //#region ../packages/common/Mappedin.Logger.d.ts
+/**
+ * SDK logging verbosity. Ordered from most verbose to least — selecting a level
+ * enables that level plus every level after it.
+ */
 declare enum E_SDK_LOG_LEVEL {
   LOG = 0,
   WARN = 1,
   ERROR = 2,
   SILENT = 3,
 }
+/**
+ * Set the SDK's global log verbosity. Lower levels include all higher-numbered levels;
+ * `SILENT` suppresses all output.
+ * @param level - The desired verbosity from {@link E_SDK_LOG_LEVEL}.
+ */
 declare function setLoggerLevel(level: E_SDK_LOG_LEVEL): void;
 //#endregion
+//#region src/utils/convert-renderer-core-options.d.ts
+/**
+ * Converts TShow3DMapOptions to RendererCoreOptions format.
+ * Transforms outdoorView.token to outdoorView.headers['x-mappedin-tiles-key'].
+ * @internal
+ */
+declare function convertToRendererCoreOptions(options: TShow3DMapOptions | undefined): Partial<RendererCoreOptions$1> | undefined;
+//#endregion
 //#region src/api-geojson/multi-floor.d.ts
+/**
+ * Multi-floor visibility state returned by {@link getMultiFloorState}, describing
+ * the outdoor opacity and per-floor state used when rendering a stacked view of
+ * multiple floors at once.
+ */
 type VisibilityState = {
   outdoorOpacity: number | 'initial';
   floorStates: {
@@ -21046,6 +21979,11 @@ type VisibilityState = {
     state: TFloorState;
   }[];
 };
+/**
+ * Configuration for the footprint rendered beneath stacked floors in multi-floor
+ * view, controlling its color, opacity, outlines, and the visual treatment of
+ * spaces open to the floor below.
+ */
 type FootprintConfig = {
   /**
    * The color of the footprint.
@@ -21505,6 +22443,23 @@ declare const checkWorkerUrls: () => Promise<false | {
   collision: boolean;
   maplibre: boolean;
 }>;
+/**
+ * Render a Mappedin map into the given DOM container and return its {@link MapView}.
+ *
+ * This is the main entry point for Mappedin JS. Combine with {@link getMapData}
+ * to load venue data and render an interactive 3D map.
+ *
+ * @param el - The container element to render the map into. Must be attached to the DOM and have non-zero size.
+ * @param mapData - Venue data, typically obtained from {@link getMapData}.
+ * @param options - Optional {@link TShow3DMapOptions} to customize the initial state, UI, and behavior of the map.
+ * @returns A promise that resolves to a {@link MapView} once the map has been initialized.
+ *
+ * @example
+ * ```ts
+ * const mapData = await getMapData({ key: '...', secret: '...', mapId: '...' });
+ * const mapView = await show3dMap(document.getElementById('mappedin-map')!, mapData);
+ * ```
+ */
 declare const show3dMap: (el: HTMLElement, mapData: MapData, options?: TShow3DMapOptions) => Promise<MapView>;
 /**
  * Returns the package version of the SDK.
@@ -21516,4 +22471,4 @@ declare const getVersion: () => string | undefined;
  */
 declare const show3dMapGeojson: (el: HTMLElement, mapData: MapData, options?: TShow3DMapOptions) => Promise<MapView>;
 //#endregion
-export { ACTION_TYPE, ANIMATION_TWEENS, type AddText3DOptions, type Analytics, Annotation, Area, type AutoElements, BBox, BEARING_TYPE, CONNECTION_TYPE, type Camera, type CameraBounds, type CameraTransform, type CaptureEventsPayloadMap, type ColorString, Connection, Coordinate, DOORS, type Debug, type DebugState, DetailedMapData, Directions, Door, E_SDK_LOG_LEVEL, EnterpriseCategory, EnterpriseLocation, EnterpriseVenue, type EnvMapOptions, type Environment, type Exporter, Facade, Feature, FeatureCollection, Floor, FloorStack, type FootprintConfig, GeoJSON$1 as GeoJSON, GeoJsonGeometryTypes, GeoJsonObject, GeoJsonProperties, GeoJsonTypes, Geometry, GeometryCollection, GeometryObject, type GlobalState, Hyperlink, type IAnchorable, type IFocusable, type IGeoJSONData, type INavigatable, type ISystemPlugin, type Image3D, type Image3DView, ImageMetaData, type InitializeModelState, type InitializeText3DState, type InsetPadding, type InsetPaddingOption, type InterpolateOn, type Interpolation, type Label, type LabelAppearance, type LabelTextPlacement, type Labels, LineString, type LineStyle, LocationCategory, LocationProfile, type LocationSocial, type LocationState, MAPPEDIN_COLORS, type MapData, type MapDataElements, type MapElementToGetRenderedState, type MapElementToGetState, type MapElementToUpdateState, type MapElementsWithState, type MapFeatureOfType, MapObject, MapView, type MapViewElements, type MapViewState, type MappedinError, type MappedinRenderError, type Marker, type Markers, type MatchInfo, type Model, type Models, type MultiFloorViewEffectState, MultiLineString, MultiPoint, MultiPolygon, type Navigation, type NavigationState, Node, type OpeningHours, type OperationHours, type Outdoor, type OutlinesOptions, type PaintStyle, type Path, type PathSegment$1 as PathSegment, type PathWidth, type Paths, type PixelWidth, type Places, Point, PointOfInterest, Polygon, type Position, type PubSub, type Query, type RendererCoreOptions, type Search, type SearchOptions, type SearchResult, type SearchResultEnterpriseCategory, type SearchResultEnterpriseLocations, type SearchResultItem, type SearchResultPlaces, type Shading, type Shape, type Shapes, type SiblingGroup, Space, type Style, type Suggestion, type TActionType, type TAddImageOptions, type TAddLabelOptions, type TAddMarkerOptions, type TAddModel, type TAddModelOptions, type TAddPathOptions, type TAddText3DAnchorableOptions, type TAddText3DOptions, type TAnalyticsUpdateState, type TAnimateStateResult, type TAnimationOptions, type TAntialiasingOptions, type TBearingType, type TCameraAnimationOptions, type TCameraInteractionsSetOptions, type TCameraTarget, type TCancellablePromise, type TClickPayload, type TCollisionRankingTier, type TConnectionPathOptions, type TConnectionType, type TCoordinateParams, type TCreateMarker, type TDirectionInstruction, type TDirectionInstructionAction, type TDirectionZone, type TDoorsState, type TDoorsUpdateState, type TEasingFunction, type TEventPayload, type TEvents, type TFacadeState, type TFacadeUpdateState, type TFindNearestOptions, type TFindNearestResult, type TFindPreferredLanguageInVenueOptions, type TFloorAltitudeData, type TFloorChangePayload, type TFloorChangeReason, type TFloorState, type TFloorUpdateState, type TFocusOnOptions, type TFocusTarget, type TGeometryState, type TGeometryUpdateState, type TGetDirectionsOptions, type TGetMapDataOptions, type TGetMapDataSharedOptions, type TGetMapDataWithAccessTokenOptions, type TGetMapDataWithCredentialsOptions, type TGetState, type THoverPayload, type THydrateMapDataBundle, type TImage3DState as TImageState, type TImage3DUpdateState as TImageUpdateState, type TLabelState, type TLabelUpdateState, type TMVF, type TMVFLineStringStyle, type TMVFPointStyle, type TMVFPolygonStyle, type TMVFStyle, type TMVFStyleCollection, type TMapDataEvents, type TMapDataObjectTypes, type TMapFeatureTypes, type TMapViewObjectTypes, type TMarkerPlacement, type TMarkerState, type TMarkerUpdateState, type TModelState, type TModelUpdateState, type TMultiFloorViewOptions, type TNavigationOptions, type TNavigationPathOptions, type TNavigationTarget, type TPathSectionHighlightOptions, type TPathState, type TPathUpdateState, type TQueriables, type TQueryAtResult, type RendererState as TRendererState, type TSearchOptions, type TSetFloorOptions, type TShapeState, type TShapeUpdateState, type TShow3DMapOptions, type TSpaceType, type TStateChangedInternalPayload, type TTakeScreenshotOptions, type TText3DState, type TText3DUpdateState, type TUpdateState, type TWallsState, type TWallsUpdateState, TWatermarkOptions, type Text3D, type Text3DView, type UpdateGlobalState, type VisibilityState, WALLS, type WithState, MapLibreOverlay as __INTERNAL__MapLibreOverlay, __setWatermarkOnClickFn, checkWorkerUrls, disableText3DWorker, enableTestMode, findPreferredLanguageInVenue, forceEnterpriseLocations, getMapData, getMapDataEnterprise, getMultiFloorState, getVersion, hydrateMapData, hydrateMapDataFromMVF, parseMVFv2 as parseMVF, preloadFont, setLoggerLevel, setUseEnterpriseAPI, setWorkersUrl, shouldForceEnterpriseLocations, show3dMap, show3dMapGeojson, unzipAndParseMVFv2, unzipMVFv2 as unzipMVF };
+export { ACTION_TYPE, ANIMATION_TWEENS, type AddText3DOptions, type Analytics, Annotation, Area, type AutoElements, BBox, BEARING_TYPE, CONNECTION_TYPE, type Camera, type CameraBounds, type CameraTransform, type CaptureEventsPayloadMap, type ColorString, Connection, Coordinate, DOORS, type Debug, type DebugState, DetailedMapData, Directions, Door, E_SDK_LOG_LEVEL, EnterpriseCategory, EnterpriseLocation, EnterpriseVenue, type EnvMapOptions, type Environment, type Exporter, Facade, Feature, FeatureCollection, Floor, FloorStack, type FootprintConfig, GeoJSON$1 as GeoJSON, GeoJsonGeometryTypes, GeoJsonObject, GeoJsonProperties, GeoJsonTypes, Geometry, GeometryCollection, GeometryObject, type GlobalState, Hyperlink, type IAnchorable, type IFocusable, type IGeoJSONData, type INavigatable, type ISystemPlugin, type Image3D, type Image3DView, ImageMetaData, type InitializeModelState, type InitializeText3DState, type InsetPadding, type InsetPaddingOption, type InterpolateOn, type Interpolation, type Label, type LabelAppearance, type LabelTextPlacement, type Labels, LineString, type LineStyle, LocationCategory, LocationProfile, type LocationSocial, type LocationState, MAPPEDIN_COLORS, type MapData, type MapDataElements, type MapElementToGetRenderedState, type MapElementToGetState, type MapElementToUpdateState, type MapElementsWithState, type MapFeatureOfType, MapObject, MapView, type MapViewElements, type MapViewState, type MappedinError, type MappedinRenderError, type Marker, type Markers, type MatchInfo, type Model, type Models, type MultiFloorViewEffectState, MultiLineString, MultiPoint, MultiPolygon, type Navigation, type NavigationState, Node, type OpeningHours, type OperationHours, type Outdoor, type OutlinesOptions, type PaintStyle, type Path, type PathSegment$1 as PathSegment, type PathWidth, type Paths, type PixelWidth, type Places, Point, PointOfInterest, Polygon, type Position, type PubSub, type Query, type RendererCoreOptions, type Search, type SearchOptions, type SearchResult, type SearchResultEnterpriseCategory, type SearchResultEnterpriseLocations, type SearchResultItem, type SearchResultPlaces, type Shading, type Shape, type Shapes, type SiblingGroup, Space, type Style, type Suggestion, type TActionType, type TAddImageOptions, type TAddLabelOptions, type TAddMarkerOptions, type TAddModel, type TAddModelOptions, type TAddPathOptions, type TAddText3DAnchorableOptions, type TAddText3DOptions, type TAnalyticsUpdateState, type TAnimateStateResult, type TAnimationOptions, type TAntialiasingOptions, type TBearingType, type TCameraAnimationOptions, type TCameraInteractionsSetOptions, type TCameraTarget, type TCancellablePromise, type TClickPayload, type TCollisionRankingTier, type TConnectionPathOptions, type TConnectionType, type TCoordinateParams, type TCreateMarker, type TDirectionInstruction, type TDirectionInstructionAction, type TDirectionZone, type TDoorsState, type TDoorsUpdateState, type TEasingFunction, type TEventPayload, type TEvents, type TExperimentalDashOptions, type TFacadeState, type TFacadeUpdateState, type TFindNearestOptions, type TFindNearestResult, type TFindPreferredLanguageInVenueOptions, type TFloorAltitudeData, type TFloorChangePayload, type TFloorChangeReason, type TFloorState, type TFloorUpdateState, type TFocusOnOptions, type TFocusTarget, type TGeometryState, type TGeometryUpdateState, type TGetDirectionsOptions, type TGetMapDataOptions, type TGetMapDataSharedOptions, type TGetMapDataWithAccessTokenOptions, type TGetMapDataWithCredentialsOptions, type TGetState, type THoverPayload, type THydrateMapDataBundle, type TImage3DState as TImageState, type TImage3DUpdateState as TImageUpdateState, type TLabelState, type TLabelUpdateState, type TMVF, type TMVFLineStringStyle, type TMVFPointStyle, type TMVFPolygonStyle, type TMVFStyle, type TMVFStyleCollection, type TMapDataEvents, type TMapDataObjectTypes, type TMapFeatureTypes, type TMapViewObjectTypes, type TMarkerPlacement, type TMarkerState, type TMarkerUpdateState, type TModelState, type TModelUpdateState, type TMultiFloorViewOptions, type TNavigationOptions, type TNavigationPathOptions, type TNavigationTarget, type TOutsideThresholdPathStyle, type TPathSectionHighlightOptions, type TPathState, type TPathUpdateState, type TQueriables, type TQueryAtResult, type RendererState as TRendererState, type TSearchOptions, type TSetFloorOptions, type TShapeState, type TShapeUpdateState, type TShow3DMapOptions, type TSpaceType, type TStateChangedInternalPayload, type TTakeScreenshotOptions, type TTetheredOptions as TTetherOptions, type TText3DState, type TText3DUpdateState, type TTrackCoordinateOptions, type TTravelledOptions, type TUpdateState, type TWallsState, type TWallsUpdateState, TWatermarkOptions, type Text3D, type Text3DView, type UpdateGlobalState, type VisibilityState, WALLS, type WithState, MAPPEDIN_LAYER_ID as __INTERNAL__MAPPEDIN_LAYER_ID, MapLibreOverlay as __INTERNAL__MapLibreOverlay, Core as __INTERNAL__RendererCore, convertToRendererCoreOptions as __INTERNAL__convertToRendererCoreOptions, __setWatermarkOnClickFn, checkWorkerUrls, disableText3DWorker, enableTestMode, findPreferredLanguageInVenue, forceEnterpriseLocations, getMapData, getMapDataEnterprise, getMultiFloorState, getVersion, hydrateMapData, hydrateMapDataFromMVF, parseMVFv2 as parseMVF, preloadFont, setLoggerLevel, setUseEnterpriseAPI, setWorkersUrl, shouldForceEnterpriseLocations, show3dMap, show3dMapGeojson, unzipAndParseMVFv2, unzipMVFv2 as unzipMVF };