@mappedin/react-sdk 6.0.1-beta.43 → 6.0.1-beta.45

package/lib/esm/index.d.ts

@@ -4,20 +4,19 @@
 //   ../react/@packages/internal/mvf-utils
 //   ../react/@mappedin/mvf
 //   ../react/@packages/internal/common/pubsub
-//   ../react/@packages/internal/mvf-utils/mvf-utils
 //   ../react/@packages/internal/common/Mappedin.Logger
 //   ../react/geojson
-//   ../react/@mappedin/mappedin-js
 //   ../react/@packages/internal/common
 //   ../react/@mappedin/core-sdk
+//   ../react/@packages/internal/mvf-utils/mvf-utils
 //   ../react/@packages/internal/mvf-utils/tokens/token-manager
+//   ../react/@tweenjs/tween.js
 //   ../react/@packages/internal/outdoor-context-v4
 //   ../react/@packages/internal/geojson-navigator
 //   ../react/@mappedin/mvf-core
 //   ../react/three
 //   ../react/zod
 //   ../react/@packages/internal/shave-text/shave-text
-//   ../react/@tweenjs/tween.js
 //   ../react/@turf/turf
 //   ../react/troika-three-text
 //   ../react/@packages/internal/quad-tree
@@ -60,12 +59,13 @@ declare module '@mappedin/react-sdk' {
 declare module '@mappedin/react-sdk/mappedin-js/src' {
     import MapData from '@mappedin/react-sdk/mappedin-js/src/map-data';
     import type { TEvents, TEventPayload, TClickPayload, THoverPayload, TFloorChangeReason } from '@mappedin/react-sdk/mappedin-js/src/events';
-    import type { TGetMapDataOptions, TGetMapDataWithAccessTokenOptions, TGetMapDataWithCredentialsOptions, TGetMapDataSharedOptions } from '@packages/internal/mvf-utils';
+    import type { TGetMapDataOptions, TGetMapDataWithAccessTokenOptions, TGetMapDataWithCredentialsOptions, TGetMapDataSharedOptions, Environment } from '@mappedin/react-sdk/packages/mvf-utils';
     import { parseMVF, unzipMVF } from '@packages/internal/mvf-utils';
     import type { Floor } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     import type { ParsedMVF as TMVF, StyleCollection as TMVFStyleCollection, Style as TMVFStyle, LineStringStyle as TMVFLineStringStyle, PolygonStyle as TMVFPolygonStyle, PointStyle as TMVFPointStyle, ParsedMVFLocalePack, OperationHours, SiblingGroup, LocationState } from '@mappedin/mvf';
     import { MapView } from '@mappedin/react-sdk/mappedin-js/src/map-view';
     export type { Text3D as Text3DApi } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/text3d';
+    export { disableText3DWorker } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/text3d';
     import type { InsetPadding, InsetPaddingOption, Shading, PaintStyle, LineStyle, Text3DState, AddText3DOptions, UpdatableText3DState, InitializeText3DState, EnvMapOptions, MapViewState, UpdateModelState, InitializeModelState, WatermarkUpdateOptions } from '@mappedin/react-sdk/geojson/src';
     import { enableTestMode, preloadFont } from '@mappedin/react-sdk/geojson/src';
     export type { PubSub } from '@packages/internal/common/pubsub';
@@ -73,7 +73,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src' {
     import { MappedinMapLibreOverlay } from '@mappedin/react-sdk/mappedin-js/src/maplibre-overlay';
     import type { LanguagePackHydrationItem, TImagePlacementOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
     import { MAPPEDIN_COLORS } from '@mappedin/react-sdk/mappedin-js/src/constants';
-    import { type Environment } from '@packages/internal/mvf-utils/mvf-utils';
     import type { TBlueDotEvents, TBlueDotAction, TBlueDotState, GeolocationPositionExtended, TFollowMode, TFollowCameraOptions } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot/blue-dot';
     import type { TExpandOptions, TStackedMapsEvents, TStackedMapsState } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/stacked-maps/stacked-maps';
     export { setLoggerLevel, E_SDK_LOG_LEVEL } from '@packages/internal/common/Mappedin.Logger';
@@ -266,12 +265,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src' {
                     floorHeight?: number;
                     updateCameraElevationOnFloorChange?: boolean;
             };
-            /**
-                * @experimental
-                * @internal
-                * @default false
-                */
-            keepOutdoorGeometryVisible?: boolean;
             /**
                 * @experimental
                 *
@@ -407,14 +400,15 @@ declare module '@mappedin/react-sdk/mappedin-js/src' {
     export { parseMVF, unzipMVF, enableTestMode, preloadFont, MAPPEDIN_COLORS };
     export type { MapView, MapData, MapViewState, MappedinMapLibreOverlay, TMappedinMapLibreOverlayEvents, TBlueDotEvents, TBlueDotAction, TBlueDotState, GeolocationPositionExtended, TStackedMapsEvents, TExpandOptions, TStackedMapsState, TFollowMode, TFollowCameraOptions, TEvents, TEventPayload, TFloorChangeReason, TClickPayload, THoverPayload, TShow3DMapOptions, TGetMapDataOptions, TGetMapDataWithAccessTokenOptions, TGetMapDataWithCredentialsOptions, TGetMapDataSharedOptions, TAntialiasingOptions, TMVF, PaintStyle, LineStyle, EnvMapOptions, Shading, TMVFStyleCollection, TMVFStyle, TMVFLineStringStyle, TMVFPolygonStyle, TMVFPointStyle, Environment, InsetPadding, InsetPaddingOption, OperationHours, SiblingGroup, LocationState, Text3DState, AddText3DOptions, UpdatableText3DState, InitializeText3DState, UpdateModelState, InitializeModelState, };
     export type * from 'geojson';
-    export type { TUpdateState, TUpdateStates, TLabelState, TGeometryState, TModelState, TShapeState, TDoorsState, TImageState, TWallsState, TCameraAnimationOptions, TAnimationOptions, TFocusOnOptions, TEasingFunction, TCameraTarget, TNavigationTarget, TDirectionZone, TAddMarkerOptions, TAddPathOptions, TLabelAppearance, TAddLabelOptions, TAddModelOptions, TAddModel, TAddImageOptions, TGetDirectionsOptions, TCollisionRankingTier, TMarkerAnchor, TDirectionInstruction, TDirectionInstructionAction, TGetState, TMarkerState, TBlueDotOptions, TBlueDotPositionUpdate, TFocusTarget, IFocusable, IAnchorable, TMapDataObjectTypes, TFloorState, TFacadeState, } from '@mappedin/react-sdk/mappedin-js/src/types';
+    export type { TUpdateState, TUpdateStates, TLabelState, TGeometryState, TModelState, TShapeState, TDoorsState, TImageState, TWallsState, TCameraAnimationOptions, TAnimationOptions, TFocusOnOptions, TEasingFunction, TCameraTarget, TNavigationTarget, TDirectionZone, TAddMarkerOptions, TAddPathOptions, TLabelAppearance, TAddLabelOptions, TAddModelOptions, TAddModel, TAddImageOptions, TGetDirectionsOptions, TCollisionRankingTier, TMarkerAnchor, TDirectionInstruction, TDirectionInstructionAction, TGetState, TMarkerState, TBlueDotOptions, TBlueDotPositionUpdate, TFocusTarget, IFocusable, IAnchorable, TMapDataObjectTypes, TFloorState, TFacadeState, TSetFloorOptions, } from '@mappedin/react-sdk/mappedin-js/src/types';
     export { WALLS, DOORS } from '@mappedin/react-sdk/mappedin-js/src/types';
     export type { Label, Marker, Path, PathSegment, Shape, CameraTransform, Model, Image, Text3D, } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
     export type { Debug } from '@mappedin/react-sdk/mappedin-js/src/debug';
     export type { Navigation, TNavigationOptions } from '@mappedin/react-sdk/mappedin-js/src/navigation';
     export type { TSpaceType } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     export { Coordinate, Annotation, Connection, Door, Floor, FloorStack, MapObject, PointOfInterest, Space, ImageMetaData, Hyperlink, EnterpriseLocation, EnterpriseCategory, EnterpriseVenue, LocationProfile, LocationCategory, Facade, Node, Area, type Places, } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
-    export type { Camera, Models, Labels, BlueDot, Markers, Paths, Exporter, Directions, Style, Shapes, Outdoor, Images, StackedMaps, DynamicFocus, } from '@mappedin/react-sdk/mappedin-js/src/api-geojson';
+    export { setWorkersUrl } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/api';
+    export type { Camera, Models, Labels, BlueDot, Markers, Paths, Exporter, Directions, Style, Shapes, Outdoor, Images, StackedMaps, } from '@mappedin/react-sdk/mappedin-js/src/api-geojson';
     export type { SearchResult, SearchResultItem, SearchResultEnterpriseCategory, SearchResultEnterpriseLocations, SearchResultPlaces, SearchOptions, Search, Suggestion, MatchInfo, } from '@mappedin/react-sdk/mappedin-js/src/search';
     export type { TFindNearestOptions, TFindNearestResult, TQueriables, Query } from '@mappedin/react-sdk/mappedin-js/src/query';
     export type { Analytics, TAnalyticsUpdateState } from '@mappedin/react-sdk/mappedin-js/src/analytics';
@@ -424,7 +418,7 @@ declare module '@mappedin/react-sdk/react-sdk/src/Marker' {
     import React, { type ReactElement, type ReactNode } from 'react';
     import type { TupleToObjectWithPropNames } from '@mappedin/react-sdk/react-sdk/src/type-utils';
     import type Mappedin from '@mappedin/react-sdk/react-sdk/src';
-    import type { TAnimationOptions } from '@mappedin/mappedin-js';
+    import type { TAnimationOptions } from '@mappedin/react-sdk/mappedin-js/src';
     type ParamsArray = Parameters<Mappedin.MapView['Markers']['add']>;
     type StreamAgentParameterNames = ['target', 'contentHtml', 'options'];
     /**
@@ -497,7 +491,7 @@ declare module '@mappedin/react-sdk/react-sdk/src/Label' {
 }
 
 declare module '@mappedin/react-sdk/react-sdk/src/useEvent' {
-    import type { TEvents } from '@mappedin/mappedin-js';
+    import type { TEvents } from '@mappedin/react-sdk/mappedin-js/src';
     /**
       * Hook to subscribe to an event on the {@link default.MapView | MapView}.
       *
@@ -1040,7 +1034,7 @@ declare module '@mappedin/react-sdk/mappedin-js/src/events' {
     import type { TBlueDotEvents } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot';
     import type { TDirectionInstruction } from '@mappedin/react-sdk/mappedin-js/src/types';
     import type { Directions } from '@mappedin/react-sdk/mappedin-js/src';
-    export type TFloorChangeReason = '' | 'blue-dot-floor-change' | 'stacked-maps-elevation-change' | 'navigation-connection-click' | 'dynamic-focus';
+    export type TFloorChangeReason = 'blue-dot-floor-change' | 'stacked-maps-elevation-change' | 'navigation-connection-click' | string;
     export type TClickPayload = {
             /**
                 * The coordinate of the interaction.
@@ -1128,14 +1122,15 @@ declare module '@mappedin/react-sdk/mappedin-js/src/events' {
                 */
             'floor-change': TFloorChangePayload;
             /**
-                * Only emitted when dynamic focus is enabled. Emitted when a different facade recieves
-                * focus due to the camera moving. This always occurs when the active floor changes to
-                * a different floor stack, but may also occur when the camera moves without the active
-                * floor changing.
+                *
+                * Emitted when a different facade recieves focus due to the camera moving.
+                * This always occurs when the active floor changes to a different floor stack,
+                * but may also occur when the camera moves without the active floor changing.
                 *
                 * @property {Facade[]} facades - The facades that are in focus.
+                *
                 */
-            'dynamic-focus-change': {
+            'facades-in-view-change': {
                     facades: Facade[];
             };
             /**
@@ -1214,6 +1209,14 @@ declare module '@mappedin/react-sdk/mappedin-js/src/events' {
     };
 }
 
+declare module '@mappedin/react-sdk/packages/mvf-utils' {
+    export * from '@mappedin/react-sdk/packages/mvf-utils/api-types';
+    export * from '@mappedin/react-sdk/packages/mvf-utils/mvf-types';
+    export type { TGetMapDataOptions, TGetMapDataWithAccessTokenOptions, TGetMapDataWithCredentialsOptions, TGetMapDataSharedOptions, TGetVenueOptions, TSearchOptions, TGetVenueBundleOptions, LocalePackUrls, Environment, } from '@mappedin/react-sdk/packages/mvf-utils/mvf-utils';
+    export { downloadVenueBundleMVF, downloadVenueBundleMVFAPIGateway, downloadMVF, parseOptions, getAccessToken, parseMVF, unzipMVF, parseMVFv1, unzipMVFv1, createEnvControl, getSasToken, parseLanguagePack, } from '@mappedin/react-sdk/packages/mvf-utils/mvf-utils';
+    export { findAndSplitObstructionByAllEntrances as splitObstructionByAllEntrances } from '@mappedin/react-sdk/packages/mvf-utils/geometry';
+}
+
 declare module '@mappedin/react-sdk/mappedin-js/src/map-data-objects' {
     import Node from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/node';
     import Area from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/area';
@@ -1510,17 +1513,17 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-data-objects' {
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
-    import type { RendererCore, WatermarkUpdateOptions } from '@mappedin/react-sdk/geojson/src';
+    import { type EasingCurve, type RendererCore, type WatermarkUpdateOptions } from '@mappedin/react-sdk/geojson/src';
     import { PubSub } from '@packages/internal/common';
     import { type TEvents, type TShow3DMapOptions } from '@mappedin/react-sdk/mappedin-js/src';
     import type { Navigation } from '@mappedin/react-sdk/mappedin-js/src/navigation';
-    import type { Camera, Labels, Markers, Models, Paths, Exporter, Directions, Style, Outdoor, Images, DynamicFocus } from '@mappedin/react-sdk/mappedin-js/src/api-geojson';
+    import type { Camera, Labels, Markers, Models, Paths, Exporter, Directions, Style, Outdoor, Images } from '@mappedin/react-sdk/mappedin-js/src/api-geojson';
     import type { BlueDot } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot/blue-dot';
     import type MapData from '@mappedin/react-sdk/mappedin-js/src/map-data';
     import { Coordinate } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     import type { Annotation, Door, Floor, MapObject, PointOfInterest, Space, Node, EnterpriseLocation, FloorStack, Facade } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     import type { TCoordinateParams } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/coordinate';
-    import type { DOORS, WALLS, TGetDirectionsOptions, TGetState, TNavigationTarget, TUpdateState, TUpdateStates, GlobalState, UpdateGlobalState } from '@mappedin/react-sdk/mappedin-js/src/types';
+    import type { DOORS, WALLS, TGetDirectionsOptions, TGetState, TNavigationTarget, TUpdateState, TUpdateStates, GlobalState, UpdateGlobalState, TSetFloorOptions, DeepPartial } from '@mappedin/react-sdk/mappedin-js/src/types';
     import type { Label, Marker, Image, Shape, Text3D as Text3DView, Model, Path } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
     import type { TEventPayload } from '@mappedin/react-sdk/mappedin-js/src/events';
     import type { Shapes } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/shapes';
@@ -1529,6 +1532,8 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
     import { Debug } from '@mappedin/react-sdk/mappedin-js/src/debug';
     import type { Text3D } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/text3d';
     import type { PathSegment } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects/path';
+    import type { ExtractDeep } from '@mappedin/react-sdk/mappedin-js/src/utils/types';
+    import { Tween } from '@tweenjs/tween.js';
     /**
         * The MapView class is the main class for rendering and interacting with the map.
         *
@@ -1597,11 +1602,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
                 * Controls for Stacked Maps.
                 */
             get StackedMaps(): StackedMaps;
-            /**
-                * @internal
-                * @experimental
-                */
-            get DynamicFocus(): DynamicFocus;
             /**
                 * @internal
                 */
@@ -1635,6 +1635,16 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
                 */
             updateState<T extends Space | Text3DView | MapObject | Label | Marker | Shape | Door | Facade | Floor | WALLS | DOORS | Model | Path | PathSegment>(target: T, state: TUpdateState<T>): any;
             updateState<T extends string & NonNullable<unknown>>(target: T, state: TUpdateStates): any;
+            /**
+                * Animate the state of a given target on the map from the current state to a new state. Only numeric properties and
+                * colors can be animated.
+                */
+            animateState<T extends Space | Model | Text3DView | MapObject | Label | Marker | Shape | Path | PathSegment | Floor>(target: T, state: DeepPartial<ExtractDeep<TGetState<T>, number | string | undefined>>, options?: {
+                    duration?: number;
+                    easing?: EasingCurve;
+            }): Promise<void> & {
+                    cancel: () => void;
+            };
             /**
                 * Update global state of the MapView
                 */
@@ -1680,12 +1690,27 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
                 * Sets the current floor ({@link Floor}) of the map.
                 * @param floor The floor or floor ID to set.
                 */
-            setFloor(floor: Floor | string): void;
+            setFloor(floor: Floor | string, options?: TSetFloorOptions): void;
             /**
                 * Sets the current floor stack ({@link FloorStack}) of the map. The default floor of the stack will be set as the current floor.
                 * @param floorStack The floor stack or floor stack ID to set.
                 */
-            setFloorStack(floorStack: FloorStack | string): void;
+            setFloorStack(floorStack: FloorStack | string, options?: TSetFloorOptions): void;
+            /**
+                * Create a tween object that will be updated on every render frame.
+                * See https://tweenjs.github.io/tween.js/docs/user_guide.html for more information.
+                *
+                * When creating a large number of tween objects, it may be important to call {@link removeTween} to prevent memory leaks.
+                *
+                * @param object The data to be tweened.
+                * @returns The tween object.
+                */
+            tween<T extends Record<string, unknown>>(object: T): Tween<T>;
+            /**
+                * Remove a tween created with {@link tween}.
+                * @param tween The tween to remove.
+                */
+            removeTween(tween: Tween<any>): void;
             /**
                 * The current floor stack ({@link FloorStack}) of the map.
                 */
@@ -1701,7 +1726,7 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
                 * @hidden
                 */
             updateWatermark(options: WatermarkUpdateOptions): void;
-            getState<T extends Space | Model | Text3DView | MapObject | Label | Marker | Image | Shape | Path | PathSegment | Floor | string>(target: T): TGetState<T>;
+            getState<T extends Space | Model | Text3DView | MapObject | Label | Marker | Image | Shape | Path | PathSegment | Floor | Facade | string>(target: T): TGetState<T>;
             setHoverColor(c: string): void;
             getHoverColor(): string | undefined;
             /**
@@ -1882,6 +1907,18 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view' {
                 * @experimental
                 */
             takeScreenshot(): Promise<string>;
+            /**
+                * @internal
+                * @hidden
+                * Whether the floor visibility is being self managed or automatically handled by the SDK.
+                */
+            get manualFloorVisibility(): boolean;
+            /**
+                * @internal
+                * @hidden
+                * Disables the default behavior of the SDK to automatically hide floors on setFloor.
+                */
+            set manualFloorVisibility(value: boolean);
     }
 }
 
@@ -1890,6 +1927,29 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/text3d' {
     import type { TAddText3DOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
     import type { CurrentMapGetter } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/types';
     import { Text3D as Text3DView } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
+    /**
+        * Disables the Text3D web worker and falls back to processing on the main thread.
+        *
+        * This function should be called when using Text3D features in environments
+        * with strict Content Security Policy (CSP) that blocks web workers from
+        * being created using blob: URLs or unsafe-eval directives.
+        *
+        * While disabling the worker may slightly impact performance for complex text
+        * rendering, it enables Text3D functionality in CSP-restricted environments.
+        *
+        * Ensure calling this before calling preloadFont
+        *
+        * @example
+        * ```typescript
+        * import {disableText3DWorker} from '@mappedin/mappedin-js';
+        * // Disable Text3D worker for CSP compatibility
+        * disableText3DWorker();
+        *
+        * // Then use Text3D features as normal
+        * mapView.Text3D.labelAll();
+        * ```
+        */
+    export function disableText3DWorker(): void;
     export class Text3D {
             #private;
             /**
@@ -1993,7 +2053,8 @@ declare module '@mappedin/react-sdk/geojson/src' {
     export type { EntityId, EntityState, LineStyle, PaintStyle, ModelProperties, Shading, ImagePlacementOptions, } from '@mappedin/react-sdk/geojson/src/types';
     export type * from 'geojson';
     export type { WatermarkUpdateOptions, WatermarkOptions, WatermarkPosition } from '@mappedin/react-sdk/geojson/src/systems/watermark/system';
-    export { preloadFont } from '@mappedin/react-sdk/geojson/src/systems/text3d/system';
+    export { preloadFont, configureWorker } from '@mappedin/react-sdk/geojson/src/systems/text3d/system';
+    export { setWorkerUrl as setCollisionWorkerUrl } from '@mappedin/react-sdk/geojson/src/systems/collisions/system';
     export type { GLTFExportOptions } from '@mappedin/react-sdk/geojson/src/systems/exporter';
     export type { AttributionControlOptions, AttributionPosition } from '@mappedin/react-sdk/geojson/src/systems/html-controls/system';
     export type { Text3DStyle, ModelStyle } from '@mappedin/react-sdk/geojson/src/components/styles';
@@ -2083,6 +2144,7 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
     import type { Language, ParsedMVFLocalePack } from '@mappedin/mvf';
     import type { InsetPaddingOption, UpdatableText3DState, Text3DState, AddText3DOptions, EnvMapOptions, InitializeModelState, ModelState, UpdateModelState as GeoJsonUpdateModelState, ImagePlacementOptions, LabelAppearance } from '@mappedin/react-sdk/geojson/src';
     import type { PathSegment } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects/path';
+    import type { TFloorChangeReason } from '@mappedin/react-sdk/mappedin-js/src/events';
     export type UpdateModelState = Omit<GeoJsonUpdateModelState, 'position' | 'scale'> & {
             position?: Coordinate;
             scale?: number | [number, number, number];
@@ -2272,6 +2334,22 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
                 * The color of the path.
                 */
             color: string;
+            /**
+                * The complete fraction of the path.
+                */
+            completeFraction: number;
+            /**
+                * The near radius of the path.
+                */
+            nearRadius: number;
+            /**
+                * The far radius of the path.
+                */
+            farRadius: number;
+            /**
+                * Whether the path is visible.
+                */
+            visible: boolean;
     };
     /**
         * Represents the state of a shape.
@@ -2309,6 +2387,10 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
                 * The opacity of the facade.
                 */
             opacity: number;
+            /**
+                * Whether the facade is visible.
+                */
+            visible: boolean;
     };
     /**
         * Defines the state for geometry elements like {@link Space} when updated.
@@ -2367,7 +2449,68 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
                         * Opacity of the floor geometry.
                         */
                     opacity: number;
+                    /**
+                        * Visibility of floor geometry.
+                        */
+                    visible: boolean;
+            };
+            labels: {
+                    /**
+                        * Whether the labels are enabled to be shown when the floor is visible.
+                        */
+                    enabled: boolean;
+            };
+            markers: {
+                    /**
+                        * Whether the markers are enabled to be shown when the floor is visible.
+                        */
+                    enabled: boolean;
+            };
+            footprint: {
+                    /**
+                        * Altitude of the footprint relative to the floor.
+                        */
+                    altitude: number;
+                    /**
+                        * Whether the footprint is visible.
+                        */
+                    visible: boolean;
+                    /**
+                        * Height of the footprint relative to altitude.
+                        */
+                    height: number;
+                    /**
+                        * Opacity of the footprint.
+                        */
+                    opacity: number;
+                    /**
+                        * Material side of the footprint.
+                        * @internal
+                        */
+                    side: 'double' | 'front' | 'back';
+                    /**
+                        * Color of the footprint.
+                        */
+                    color: string;
+            };
+            /**
+                * @internal
+                */
+            occlusion: {
+                    /**
+                        * @internal
+                        * Whether this floor should occlude labels and markers on other floors
+                        */
+                    enabled: boolean;
             };
+            /**
+                * The visibility of the floor, including the geometry, labels, and markers.
+                */
+            visible: boolean;
+            /**
+                * The altitude of the floor.
+                */
+            altitude: number;
     };
     export enum WALLS {
             Exterior = "exterior-walls",
@@ -2380,7 +2523,7 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
     /**
         * The type for updating the state of map elements (colors, texts, etc.).
         */
-    export type TUpdateState<T> = T extends WALLS ? Partial<TWallsState> : T extends DOORS | Door ? Partial<TDoorsState> : T extends Model ? Partial<UpdateModelState> : T extends Marker ? Partial<TMarkerState> : T extends Label ? Partial<TLabelState> : T extends Space | MapObject ? Partial<TGeometryState> : T extends Floor ? Partial<TFloorState> : T extends Facade ? Partial<TFacadeState> : T extends Shape ? Partial<Omit<TShapeState, 'height' | 'type'>> : T extends Text3D ? UpdatableText3DState : T extends Path ? Partial<TPathState> : T extends PathSegment ? Partial<TPathState> : T extends string ? Record<string, any> : never;
+    export type TUpdateState<T> = T extends WALLS ? Partial<TWallsState> : T extends DOORS | Door ? Partial<TDoorsState> : T extends Model ? Partial<UpdateModelState> : T extends Marker ? Partial<TMarkerState> : T extends Label ? Partial<TLabelState> : T extends Space | MapObject ? Partial<TGeometryState> : T extends Floor ? DeepPartial<TFloorState> : T extends Facade ? Partial<TFacadeState> : T extends Shape ? Partial<Omit<TShapeState, 'height' | 'type'>> : T extends Text3D ? UpdatableText3DState : T extends Path ? Partial<TPathState> : T extends PathSegment ? Partial<TPathState> : T extends string ? Record<string, any> : never;
     export type TUpdateStates = Partial<Omit<TGeometryState, 'interactive' | 'hoverColor' | 'type'>> | Partial<TMarkerState> | Partial<TLabelState> | Partial<TGeometryState> | Partial<TPathState>;
     export type TGetState<T> = T extends WALLS ? TWallsState | undefined : T extends DOORS ? TDoorsState | undefined : T extends Marker ? TMarkerState | undefined : T extends Shape ? TShapeState | undefined : T extends Model ? TModelState | undefined : T extends Label ? TLabelState | undefined : T extends Image ? TImageState | undefined : T extends Text3D ? Text3DState | undefined : T extends Space | MapObject ? TGeometryState | undefined : T extends Floor ? TFloorState | undefined : T extends Facade ? TFacadeState | undefined : T extends Path ? TPathState | undefined : T extends PathSegment ? TPathState | undefined : T extends string ? TLabelState | TGeometryState | TMarkerState | TModelState | TPathState | undefined : never;
     /**
@@ -2848,6 +2991,28 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
                 * sorting of markers and show certain markers always in front
                 */
             zIndex?: number;
+            /**
+                * Configuration for the low priority pin fallback strategy.
+                * When enabled, shows a smaller pin version of the marker when all anchor positions have collisions.
+                * @default { enabled: true, size: 2, color: '#666' }
+                */
+            lowPriorityPin?: {
+                    /**
+                        * Whether to enable low priority pin strategy when all anchor positions have collisions.
+                        * @default true
+                        */
+                    enabled?: boolean;
+                    /**
+                        * Size of the low priority pin in pixels.
+                        * @default 2
+                        */
+                    size?: number;
+                    /**
+                        * Color of the low priority pin.
+                        * @default '#666'
+                        */
+                    color?: string;
+            };
     };
     /**
         * Options for creating a new {@link Label} with {@link Labels.add}.
@@ -3064,6 +3229,12 @@ declare module '@mappedin/react-sdk/mappedin-js/src/types' {
                 */
             bearingAndPitch?: boolean;
     };
+    export type TSetFloorOptions = {
+            /**
+                * Optionally provide the context for the floor change which will be published as the `reason` for the `floor-change` event.
+                */
+            context?: TFloorChangeReason;
+    };
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/constants' {
@@ -3454,7 +3625,7 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view-objects' {
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/debug' {
-    import type { RendererCore } from '@mappedin/core-sdk';
+    import type { RendererCore } from '@mappedin/react-sdk/geojson/src';
     export class Debug {
         state: RendererCore['Debug']['state'];
         constructor(core: RendererCore);
@@ -3557,6 +3728,11 @@ declare module '@mappedin/react-sdk/mappedin-js/src/navigation' {
                         */
                     animateArrowsOnPath?: boolean;
             };
+            /**
+                * Controls whether the path drawing is animated across floors.
+                * @default true
+                */
+            animatePathDrawing?: boolean;
             /**
                 * Options for the path.
                 */
@@ -3717,6 +3893,141 @@ declare module '@mappedin/react-sdk/mappedin-js/src/navigation' {
     export {};
 }
 
+declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/api' {
+    import type { RendererCore, WatermarkUpdateOptions } from '@mappedin/core-sdk';
+    import { type TShow3DMapOptions } from '@mappedin/react-sdk/mappedin-js/src';
+    import { WALLS, DOORS } from '@mappedin/react-sdk/mappedin-js/src/types';
+    import type MapData from '@mappedin/react-sdk/mappedin-js/src/map-data';
+    import type { FloorStack, MapDataInternal } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
+    import { Facade, Coordinate, MapObject, Space, Floor, Door } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
+    import type { MapView } from '@mappedin/react-sdk/mappedin-js/src/map-view';
+    import { Label, Marker, Shape } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
+    import { Text3D as Text3DView, Model, Path, type Image } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
+    import { Navigation } from '@mappedin/react-sdk/mappedin-js/src/navigation';
+    import type { TGetState, TUpdateState } from '@mappedin/react-sdk/mappedin-js/src/types';
+    import { Camera } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/camera';
+    import { Exporter } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/exporter';
+    import { Labels } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/labels';
+    import { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
+    import { Markers } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/markers';
+    import { Images } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/images';
+    import { Models } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/models';
+    import { Paths } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/paths';
+    import { BlueDot } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot/blue-dot';
+    import type { TFloorChangeReason } from '@mappedin/react-sdk/mappedin-js/src/events';
+    import { Shapes } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/shapes';
+    import { Style } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/style';
+    import Outdoor from '@mappedin/react-sdk/mappedin-js/src/api-geojson/outdoor';
+    import { type BBox } from 'geojson';
+    import { Text3D } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/text3d';
+    import { PathSegment } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects/path';
+    import { Tween } from '@tweenjs/tween.js';
+    export class GeoJsonApi {
+            core: RendererCore;
+            mapObjects: GeojsonApiMapObject[];
+            id: string;
+            mapDataExternal: {
+                    [key in string]: MapData;
+            };
+            mapData?: MapData;
+            currentMap: GeojsonApiMapObject;
+            hiddenOutdoorGeometries: [
+                    BBox,
+                    polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[],
+                    layers: string[]
+            ][];
+            manualFloorVisibility: boolean;
+            mapView: MapView;
+            Camera: Camera;
+            Labels: Labels;
+            Text3D: Text3D;
+            Markers: Markers;
+            Models: Models;
+            Paths: Paths;
+            Exporter: Exporter;
+            Navigation: Navigation;
+            Outdoor: Outdoor;
+            BlueDot: BlueDot;
+            Shapes: Shapes;
+            Style: Style;
+            Images: Images;
+            get StackedMaps(): import("..").StackedMaps;
+            constructor(rendererCore: RendererCore, mapView: MapView);
+            updateState<T extends Space | Text3DView | MapObject | Label | Shape | Marker | Model | Door | Facade | Floor | WALLS | DOORS | Path | PathSegment | (string & NonNullable<unknown>)>(target: T, state: TUpdateState<T>): void;
+            update: () => void;
+            getMapDataInternal(): MapDataInternal | undefined;
+            getMapData(): MapData | undefined;
+            addMap(mapData: MapData, options?: TShow3DMapOptions): Promise<MapData>;
+            setFloor(floor: Floor | string, reason?: TFloorChangeReason): void;
+            setFloorStack(floorStack: FloorStack | string, reason?: TFloorChangeReason): void;
+            updateWatermark(options: WatermarkUpdateOptions): void;
+            get currentFloorStack(): FloorStack;
+            get currentFloor(): Floor;
+            getState<T extends Space | Text3DView | MapObject | Label | Marker | Image | Shape | Model | Path | PathSegment | Floor | Facade | string>(target: T): TGetState<T>;
+            setHoverColor(c: string): void;
+            getHoverColor(): string | undefined;
+            /**
+                * Create a coordinate from a screen coordinate
+                * @param x - The x coordinate of the screen
+                * @param y - The y coordinate of the screen
+                * @param floor - The floor to use for the coordinate
+                * @returns The coordinate
+                */
+            createCoordinateFromScreenCoordinate(x: number, y: number, floor?: Floor): Coordinate | undefined;
+            getScreenCoordinateFromCoordinate(coordinate: Coordinate): {
+                    x: number;
+                    y: number;
+            };
+            isInView(target: Space | MapObject | Label | Marker | string): boolean;
+            auto(): {
+                    labels: Label[];
+            };
+            tween<T extends Record<string, unknown>>(object: T): Tween<T>;
+            removeTween(tween: Tween<any>): void;
+            /**
+                * @internal
+                */
+            get __core(): RendererCore;
+            clear(): void;
+            destroy(): void;
+    }
+    /**
+        * Sets the base URL directory where worker scripts are hosted for CSP compatibility.
+        *
+        * This function configures both the MapLibre and collision system workers to load from
+        * external URLs instead of using inline blob URLs. The SDK expects two specific worker
+        * files to be available in the provided directory:
+        * - `maplibre-worker.csp.js` - For MapLibre map rendering
+        * - `collision-worker.csp.js` - For the collision detection system
+        *
+        * Using this approach enables compatibility with strict Content Security Policies
+        * that block unsafe-eval and blob: URLs.
+        *
+        * @param baseUrl - Base URL directory where worker scripts are hosted (without trailing slash)
+        *                  Example: "https://cdn.example.com/workers"
+        *
+        * @example
+        * ```typescript
+        * import { setWorkersUrl } from '@mappedin/mappedin-js';
+        *
+        * // Call before initializing any maps
+        * setWorkersUrl('https://cdn.example.com/workers');
+        * // This will load:
+        * // - https://cdn.example.com/workers/maplibre-worker.csp.js
+        * // - https://cdn.example.com/workers/collision-worker.csp.js
+        * ```
+        *
+        * @remarks
+        * - The worker files can be found in the published package at:
+        *   `node_modules/@mappedin/mappedin-js/lib/esm/workers/`
+        * - For deployment, copy these files to your web server or CDN
+        * - A better approach is to add these files to your build process to ensure
+        *   they're always in sync with your application
+        * - Call this function before creating any map instances
+        */
+    export function setWorkersUrl(baseUrl: string): void;
+}
+
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson' {
     export { GeoJsonApi } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/api';
     export { BlueDot } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot';
@@ -3733,7 +4044,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson' {
     export { default as Outdoor } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/outdoor';
     export { Images } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/images';
     export { StackedMaps } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/stacked-maps/stacked-maps';
-    export { DynamicFocus } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/dynamic-focus';
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/search' {
@@ -3985,33 +4295,819 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot' {
     export type { TBlueDotEvents, GeolocationPositionExtended, TFollowCameraOptions, TFollowMode } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot/blue-dot';
 }
 
-declare module '@mappedin/react-sdk/mappedin-js/src/map-data-objects/node' {
-    import type { NodeCollection } from '@mappedin/mvf';
-    import Coordinate from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/coordinate';
-    import type { EnterpriseLocation, MapDataInternal, Space } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
-    import type Floor from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/floor';
-    import BaseMetaData from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/base-metadata-object';
-    import type { IGeoJSONData } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/types';
-    import type { IAnchorable, IFocusable } from '@mappedin/react-sdk/mappedin-js/src/types';
+declare module '@mappedin/react-sdk/packages/mvf-utils/api-types' {
     /**
-        * A class representing {@link Path} node data within the map.
-        *
-        * Nodes are used to define points in the map's pathfinding graph.
-        *
-        */
-    class Node extends BaseMetaData implements IGeoJSONData, IFocusable, IAnchorable {
-            #private;
-            /**
-                * @internal
-                */
-            static readonly __type = "node";
-            /**
-                * @internal
-                */
-            readonly __type = "node";
-            /**
-                * Checks if the provided instance is of type Node.
-                *
+      * This file contains the API types for MappedinSDK - before they get turned into Classes
+      */
+    export type TLocationType = 'amenities' | 'tenant';
+    export type TNode = {
+        id: string;
+        x: number;
+        y: number;
+        map: string;
+        externalId?: string;
+        paths: {
+            node: string;
+            map: string;
+            weight?: number;
+        }[];
+        [propName: string]: any;
+    };
+    export type TImage = {
+        original?: string;
+        large?: string;
+        '140x140'?: string;
+        xxlarge?: string;
+        xsmall?: string;
+        '66x66'?: string;
+        xlarge?: string;
+        medium?: string;
+        xxsmall?: string;
+        small?: string;
+    };
+    export type TLogo = TImage;
+    export type TGalleryImage = {
+        image: TImage;
+        caption?: string;
+    };
+    export type TPhone = {
+        number?: string;
+    };
+    export type TSocial = {
+        website?: string;
+        twitter?: string;
+        facebook?: string;
+        instagram?: string;
+    };
+    export type TColor = {
+        hex: string;
+        opacity: number;
+        rgba: string;
+    };
+    export type TVortex = {
+        id: string;
+        name: string;
+        type: string;
+        weight: number;
+        multiplier: number;
+        [propName: string]: any;
+    };
+    export type TPicture = {
+        original?: string;
+    };
+    export type TOpeningHours = {
+        '@type': string;
+        opens: string;
+        closes: string;
+        dayOfWeek: string[];
+        validFrom?: string;
+        validThrough?: string;
+    };
+    export type TSiblingGroup = {
+        label: string;
+        siblings: string[];
+    };
+    export type TState = {
+        type: string;
+        start?: string;
+        end?: string;
+    };
+    export type TCategory = {
+        name?: string;
+        externalId?: string;
+        parents?: string[];
+        id?: string;
+        icon?: TPicture;
+    };
+    export type TEvent = {
+        id: string;
+        type: string;
+        name: string;
+        location?: string;
+        description?: string;
+        image?: TImage;
+        startDate?: number;
+        endDate?: number;
+        showDate?: number;
+    };
+    export interface TGeoReference {
+        target: {
+            x: number;
+            y: number;
+        };
+        control: {
+            x: number;
+            y: number;
+        };
+    }
+    export interface TMap {
+        id: string;
+        name: string;
+        shortName: string;
+        elevation?: number;
+        scale?: number;
+        x_scale?: number;
+        georeference?: TGeoReference[];
+        [propName: string]: any;
+    }
+    export type TMapGroup = {
+        name: string;
+        id: string;
+    };
+    export type TBuilding = TLocation & {
+        groupId: string;
+    };
+    export type TLocation = {
+        id: string;
+        name: string;
+        type: string;
+        nodes: {
+            map: TMap['id'];
+            node: TNode['id'];
+        }[];
+        polygons: {
+            map: TMap['id'];
+            id: TPolygon['id'];
+        }[];
+        categories: string[];
+        description?: string;
+        sortOrder?: number;
+        logo?: TLogo;
+        phone?: TPhone;
+        social?: TSocial;
+        color?: TColor;
+        shortName?: string;
+        detailsUrl?: string;
+        parent?: string | null;
+        tags?: string[];
+        externalId?: string;
+        picture?: TPicture;
+        states?: TState[];
+        operationHours?: TOpeningHours[] | undefined;
+        siblingGroups?: TSiblingGroup[] | undefined;
+        gallery?: TGalleryImage[] | undefined;
+        [propName: string]: any;
+    };
+    export type TPolygon = {
+        id: string;
+        map: string;
+        layer?: string;
+        layerId?: string;
+        externalId?: string;
+        name?: string;
+        entrances: {
+            map: TMap['id'];
+            id: TNode['id'];
+        }[];
+    };
+    export type TPolygonRanking = {
+        polygonId: string;
+        entranceNodeId: string;
+        score: number;
+    };
+    export type TLocationState = {
+        id: string;
+        name: string;
+        value: string;
+    };
+    export type TVenue = {
+        address?: string;
+        city?: string;
+        countrycode?: string;
+        defaultMap?: string;
+        externalId?: string;
+        id?: string;
+        latitude?: number;
+        logo?: TLogo;
+        longitude?: number;
+        metadata?: any;
+        name?: string;
+        operationHours?: TOpeningHours[];
+        postal?: string;
+        slug?: string;
+        state?: string;
+        telephone?: string;
+        tzid?: string;
+        tzidOverride?: string;
+        utcOffset?: string;
+        website?: string;
+    };
+    export type TMappedinAPI = {
+        nodes: TNode[];
+        locations: TLocation[];
+        categories: TCategory[];
+        mapGroups: TMapGroup[];
+        polygons: TPolygon[];
+        maps: TMap[];
+        themes: any;
+        venue: TVenue;
+        vortexes: TVortex[];
+        locationStates?: TLocationState[];
+        imageBinaries?: Map<string, Uint8Array>;
+    };
+}
+
+declare module '@mappedin/react-sdk/packages/mvf-utils/mvf-types' {
+    import type { MapId, Style, Feature, LineString, ObstructionProperties, EntranceProperties, SpaceProperties, ObstructionCollection, EntranceCollection, SpaceCollection, FloorImageProperties, BaseTextAreaProperties, EnterpriseTexture } from '@mappedin/mvf';
+    import type { FeatureCollection, MultiPolygon, Point, Polygon } from 'geojson';
+    import type { TImage, TMap, TNode, TOpeningHours, TPhone, TSiblingGroup, TSocial } from '@mappedin/react-sdk/packages/mvf-utils/api-types';
+    export type WithIDs<T> = Map<string, T>;
+    type ManifestFile = {
+            type: 'file';
+            name: string;
+    };
+    type ManifestFolder = {
+            type: 'folder';
+            name: string;
+            children: ManifestFile[];
+    };
+    export type MVFStyle = Style & {
+            type: string;
+            width?: number;
+    };
+    export type MVFObstructionFeature = ObstructionCollection['features'][number];
+    export type MVFEntranceFeature = EntranceCollection['features'][number];
+    export type MVFSpaceFeature = SpaceCollection['features'][number];
+    export type WithPolygonImage<T extends SpaceProperties | ObstructionProperties> = T & {
+            image?: FloorImageProperties;
+    };
+    export type WithTextArea<T extends SpaceProperties | ObstructionProperties> = T & {
+            textArea?: BaseTextAreaProperties;
+    };
+    export type WithEntepriseStyle<T extends SpaceProperties | ObstructionProperties> = T & {
+            style?: {
+                    styleId: string;
+                    edgeOffset?: number;
+            };
+    };
+    export type WithTextures<T extends SpaceProperties | ObstructionProperties> = T & {
+            textures?: EnterpriseTexture[];
+    };
+    export type PolygonFeatureProperties<T extends SpaceProperties | ObstructionProperties> = WithEntepriseStyle<T> | WithPolygonImage<T> | WithTextures<T>;
+    export type MVFv1PolygonLikeProperties = {
+            id: string;
+            altitude?: number;
+            color?: string;
+            externalId?: string | null;
+            height?: number;
+            opacity?: number;
+            layer?: string;
+            level: string;
+            parent?: string | null;
+    };
+    export type MVFv1SpaceProperties = MVFv1PolygonLikeProperties & {
+            entrances: {
+                    level: TMap['id'];
+                    id: TNode['id'];
+            }[];
+    };
+    export type MVFv1ObstructionProperties = MVFv1PolygonLikeProperties;
+    export type MVFv1ConnectionProperties = {
+            id: string;
+            /**
+                * Indicates that a connection is accessible
+                */
+            accessible: boolean;
+            /**
+                * Array of node ids that this Connection connects with.
+                */
+            destinations: string[];
+            level: string;
+            multiplier: number;
+            name: string;
+            /**
+                * Type of the connection such as `escalator` or `elevator`
+                */
+            type: string;
+            weight: number;
+    };
+    export type MVFv1NodeProperties = {
+            id: string;
+            /**
+                * Indicates that a node is accessible
+                */
+            accessible: boolean;
+            /**
+                * External id of a node is used to sync and connect to external systems to Mappedin data
+                */
+            externalId: string | null;
+            level: string;
+            multiplier: number;
+            neighbors: string[];
+            weight: number;
+    };
+    export type MVFv1LevelProperties = {
+            id: string;
+            abbreviation?: string;
+            building?: string;
+            elevation?: number;
+            name: string;
+    };
+    export type MVFv1ManifestProperties = {
+            /**
+                * Name of the venue
+                */
+            name: string;
+            folder_struct: (ManifestFolder | ManifestFile)[];
+            /**
+                * Mappedin Venue Format version number of the MVF bundle
+                */
+            version: string;
+            /**
+                * Timestamp when the MVF bundle was generated. E.g. `2022-02-25T16:26:09.908Z`
+                */
+            time: string;
+    };
+    export type MVFv1BuildingProperties = {
+            id: string;
+            name: string;
+            venue: string;
+    };
+    export type MVFv1CategoryProperties = {
+            id: string;
+            name: string;
+            picture?: TImage;
+    };
+    export type MVFv1LocationProperties = {
+            id: string;
+            address?: string | null;
+            /**
+                * Array of {@link MICategoryProperties | category} ids
+                */
+            categories: string[];
+            /**
+                * A text description of the location usually indicating what the location is used for
+                */
+            description?: string | null;
+            /**
+                * Email address to for contacting this location
+                */
+            email?: string | null;
+            /**
+                * External id used to connect Mappedin Location to an external system
+                */
+            externalId?: string | null;
+            /**
+                * Opening hours of the location
+                */
+            hours?: TOpeningHours[] | null;
+            /**
+                * Collection of links related to this location
+                */
+            links?: {
+                    label: string;
+                    url: string;
+            }[] | null;
+            logo?: TImage | null;
+            /**
+                * Name of the location. By default this is the string displayed in the location label
+                */
+            name: string;
+            /**
+                * Phone number for contacting this location
+                */
+            phone?: TPhone | null;
+            picture?: TImage | null;
+            services?: string | null;
+            siblingGroups?: TSiblingGroup[] | null;
+            /**
+                * Social media links of the location
+                */
+            social?: TSocial | null;
+            /**
+                * Array of {@link MISpaceProperties | MVF Space} ids for this location
+                */
+            spaces?: {
+                    id: string;
+                    map: string;
+            }[] | null;
+            states?: {
+                    type: string;
+                    start?: string;
+                    end?: string;
+            }[] | null;
+            type: string;
+    };
+    export type MVFv1ObstructionCollection = FeatureCollection<Polygon, MVFv1ObstructionProperties>;
+    export type MVFv1SpaceCollection = FeatureCollection<Polygon, MVFv1SpaceProperties>;
+    export type MVFv1ConnectionCollection = FeatureCollection<Point, MVFv1ConnectionProperties>;
+    export type MVFv1NodeCollection = FeatureCollection<Point, MVFv1NodeProperties>;
+    export type MVFv1LevelCollection = FeatureCollection<Polygon | MultiPolygon, MVFv1LevelProperties>;
+    export type MVFv1ManifestCollection = FeatureCollection<Point, MVFv1ManifestProperties>;
+    export type MVFv1BuildingCollection = FeatureCollection<Polygon, MVFv1BuildingProperties>;
+    export type MVFv1CategoryCollection = FeatureCollection<null, MVFv1CategoryProperties>;
+    export type MVFv1LocationCollection = FeatureCollection<null, MVFv1LocationProperties>;
+    export type ParsedMVFv1 = {
+            /**
+                * @propertyNames { "pattern": "^m_[0-9a-z]{16}$" }
+                */
+            space: {
+                    [mapId: MapId]: MVFv1SpaceCollection | undefined;
+            };
+            /**
+                * @propertyNames { "pattern": "^m_[0-9a-z]{16}$" }
+                */
+            obstruction: {
+                    [mapId: MapId]: MVFv1ObstructionCollection | undefined;
+            };
+            /**
+                * @propertyNames { "pattern": "^m_[0-9a-z]{16}$" }
+                */
+            level: {
+                    [mapId: MapId]: MVFv1LevelCollection | undefined;
+            };
+            /**
+                * @propertyNames { "pattern": "^m_[0-9a-z]{16}$" }
+                */
+            node: {
+                    [mapId: MapId]: MVFv1NodeCollection | undefined;
+            };
+            /**
+                * @propertyNames { "pattern": "^m_[0-9a-z]{16}$" }
+                */
+            connection: {
+                    [mapId: MapId]: MVFv1ConnectionCollection | undefined;
+            };
+            'manifest.geojson': MVFv1ManifestCollection;
+            'building.geojson': MVFv1BuildingCollection;
+            'category.geojson': MVFv1CategoryCollection;
+            'location.geojson': MVFv1LocationCollection;
+    };
+    export type RawMVFv1 = {
+            'manifest.geojson': Uint8Array;
+            'building.geojson': Uint8Array;
+            'category.geojson': Uint8Array;
+            'location.geojson': Uint8Array;
+            level: Partial<Record<MapId, Uint8Array>>;
+            node: Partial<Record<MapId, Uint8Array>>;
+            space: Partial<Record<MapId, Uint8Array>>;
+            obstruction: Partial<Record<MapId, Uint8Array>>;
+            connection: Partial<Record<MapId, Uint8Array>>;
+    };
+    export type ObstructionFeature = Feature<LineString | Polygon, ObstructionProperties>;
+    export type ObstructionWallFeature = Feature<LineString, ObstructionProperties>;
+    export type EntranceFeature = Feature<LineString, EntranceProperties>;
+    export {};
+}
+
+declare module '@mappedin/react-sdk/packages/mvf-utils/mvf-utils' {
+    import { type ParsedMVF, type ParsedMVFLocalePack, type RawMVF } from '@mappedin/mvf';
+    import type { ParsedMVFv1, RawMVFv1 } from '@mappedin/react-sdk/packages/mvf-utils/mvf-types';
+    export * from '@mappedin/react-sdk/packages/mvf-utils/tokens/access-token';
+    export * from '@mappedin/react-sdk/packages/mvf-utils/tokens/sas-token';
+    /**
+        * This is how we can avoid bundling in node-fetch (via isomorphic fetch),
+        * which keeps popping up in security advisories
+        * This is a pattern that most isomorphic libraries appear to use,
+        * where when running in node, you can pass your own fetch function
+        * as one is not provided by Node.js.
+        *
+        */
+    export function isomorphicFetch(): Window['fetch'];
+    /**
+        * @internal
+        * export for test mocking
+        */
+    export function __setFetchFn(fn: any): void;
+    export type TGetVenueOptions = {
+            accessToken?: string;
+            clientId?: string;
+            clientSecret?: string;
+            baseUrl?: string;
+            includeHidden?: boolean;
+            noAuth?: boolean;
+            perspective?: string;
+            language?: string;
+            headers?: {
+                    [key in string]: string;
+            };
+            venue: string;
+            /**
+                * An object specifying additional properties to fetch for each data item.
+                * Each key represents a data item (e.g., 'locations', 'nodes'), and the value is an array of strings indicating extra properties to be included.
+                * @example
+                * For example:
+                * ```
+                * getVenue({
+                *   venue: 'some-venue',
+                *   things: { vortexes: [ 'material' ]
+                * }})
+                * ```
+                */
+            things?: any;
+            useDraftData?: boolean;
+            platformString?: string;
+            secure?: boolean;
+            preloadMapGeometry?: boolean;
+    };
+    export type TGetVenueBundleOptions = TGetVenueOptions & {
+            baseUri?: string;
+            version?: string;
+            /**
+                * Parse bundle and convert images to blobs. Disabled in React Native
+                * @private
+                */
+            shouldPopulateBundledImagesAsBlobs?: boolean;
+    };
+    /** @internal */
+    export type TGetVenueMVFOptions = TGetVenueBundleOptions & {
+            onMVFParsed?: (mvf: ParsedMVF) => void;
+            /**
+                * Override initial MVF data
+                */
+            override?: Partial<Pick<ParsedMVF, 'styles.json'>>;
+    };
+    /**
+        * Options for configuring search functionality.
+        */
+    export type TSearchOptions = {
+            /**
+                * Indicates whether search functionality is enabled.
+                */
+            enabled: boolean;
+    };
+    export type TGetMapDataSharedOptions = {
+            /**
+                * Mappedin map ID.
+                */
+            mapId: string;
+            /**
+                * Optionally provide a custom base URL for the Mappedin API request.
+                * Use the {@link Environment | `environment`} setting to switch environments
+                */
+            baseUri?: string;
+            /**
+                * Optionally provide a custom URI for authentication when obtaining an access token.
+                * Use the {@link Environment | `environment`} setting to switch environments.
+                */
+            baseAuthUri?: string;
+            /**
+                * Callback for when the Mappedin map data has been fetched and parsed as Mappedin Venue Format (MVF) data.
+                * @param mvf Parsed MVF data.
+                */
+            onMVFParsed?: (mvf: ParsedMVF) => void;
+            /**
+                * Load different view of mvf data based on configId
+                */
+            viewId?: string;
+            /**
+                * set the target SDK environment
+                * @default 'us'
+                * @example
+                * const mapData = getMapData({
+                *  key: '',
+                *  secret: '',
+                *  environment: 'eu'
+                * })
+                */
+            environment?: ServiceEnvironment;
+            /**
+                * The language of the map data.
+                * The ISO 639-1 language code to change to (e.g., 'en' for English, 'fr' for French). Check ({@link EnterpriseVenue.languages}) for available languages
+                */
+            language?: string;
+            /**
+                * Analytics configuration.
+                */
+            analytics?: {
+                    /**
+                        * Whether to log analytics events.
+                        * @default false
+                        */
+                    logEvents?: boolean;
+                    /**
+                        * Whether to send analytics events to the server.
+                        * @default false
+                        */
+                    sendEvents?: boolean;
+                    /**
+                        * Custom base URI for analytics requests. If not provided, the default analytics endpoint will be used.
+                        * Use the {@link Environment | `environment`} setting to switch environments.
+                        */
+                    baseUri?: string;
+                    /**
+                        * Context for analytics events.
+                        * @default 'websdk'
+                        * @internal
+                        */
+                    context?: string;
+            };
+            search?: TSearchOptions;
+            /**
+                * @hidden
+                * @internal
+                */
+            layoutId?: 'draft';
+    };
+    /**
+        * @interface
+        */
+    export type TGetMapDataWithCredentialsOptions = {
+            /**
+                * Mappedin auth key.
+                */
+            key: string;
+            /**
+                * Mappedin auth secret.
+                */
+            secret: string;
+    } & TGetMapDataSharedOptions;
+    /**
+        * @interface
+        */
+    export type TGetMapDataWithAccessTokenOptions = {
+            /**
+                * Mappedin access token.
+                */
+            accessToken: string;
+    } & TGetMapDataSharedOptions;
+    export type TGetMapDataOptions = TGetMapDataWithCredentialsOptions | TGetMapDataWithAccessTokenOptions;
+    export type TProcessedMVFOptions = TGetMapDataOptions & {
+            clientId: string;
+            clientSecret: string;
+            venue: string;
+            accessToken: string;
+    };
+    export type TAllGetVenueOptions = TGetVenueOptions | TGetVenueMVFOptions | (TProcessedMVFOptions & {
+            perspective?: string;
+    });
+    export type TGetVenueOptionsInternal<T extends TAllGetVenueOptions> = Omit<T & {
+            baseUrl?: string;
+            supplementaryUrl?: string;
+            noAuth?: boolean;
+            includeHidden?: boolean;
+            apiGateway?: string;
+            authorization?: string;
+            headers?: any;
+    }, 'things'> & {
+            things?: any;
+    };
+    export const defaultOptions: TGetVenueOptionsInternal<TGetVenueOptions>;
+    /**
+        * @internal
+        */
+    export function parseOptions<T extends TAllGetVenueOptions>(options: T): TGetVenueOptionsInternal<T>;
+    /**
+        * Prepares the request and URL fields to pass into generateAPIRequest
+        * @param options options from getVenue- baseUrl and supplementaryUrl are used
+        * @param url string describing the url corresponding to the client's request
+        * @param supplementary whether to use the supplementaryUrl when sending the request
+        */
+    export function constructParamsForRequest(options: TGetVenueOptionsInternal<TGetVenueOptions>, url: string, supplementary?: boolean): {
+            req: {
+                    method: string;
+                    headers: any;
+            };
+            url: string;
+    };
+    export function generateAPIRequest(options: TGetVenueOptionsInternal<TGetVenueOptions>, url: string, supplementary?: boolean): Promise<any>;
+    export const getPerspectivesFromResponse: (res: unknown) => Record<string, {
+            url: string;
+            locale_packs: LocalePackUrls;
+    }> | null;
+    /**
+        * Get the bundle URL and updated_at time.
+        * @internal
+        */
+    export function getVenueMVFURL(userOptions: TGetVenueBundleOptions, path?: string): Promise<{
+            url: any;
+            localePacks: any;
+            updated_at: any;
+    }>;
+    export function getLanguagePackUnitArray(url: string, { signal }: {
+            signal: AbortSignal;
+    }): Promise<Uint8Array>;
+    export function parseLanguagePack(data: Uint8Array): Promise<ParsedMVFLocalePack>;
+    export function downloadLanguagePack(url: string, { signal }: {
+            signal: AbortSignal;
+    }): Promise<ParsedMVFLocalePack | undefined>;
+    export function downloadVenueBundleMVFAPIGateway(options: TGetVenueBundleOptions): Promise<{
+            compressed: Uint8Array;
+            localePacks: LocalePackUrls;
+    }>;
+    export function downloadVenueBundleMVF(options: TGetVenueBundleOptions): Promise<Uint8Array>;
+    export function parseMVFv1(raw: RawMVFv1): ParsedMVFv1;
+    export function validateStaticMVFv1Files(data: unknown): boolean;
+    export function unzipMVFv1(data: any): Promise<RawMVFv1>;
+    export function downloadMVF(userOptions: TGetMapDataOptions, accessToken: string): Promise<Uint8Array>;
+    export function getMakerBundleURL(userOptions: TGetMapDataOptions, token: string): Promise<{
+            url: string;
+            updated_at: string;
+    }>;
+    /**
+        * @internal
+        */
+    export function parseMVF(raw: RawMVF & {
+            options?: {
+                    outdoorViewToken?: string;
+            };
+    }): ParsedMVF;
+    /**
+        * Figure out if the MVF data at least has the static files we expect.
+        */
+    export function validateStaticMVFFiles(data: unknown): boolean;
+    /**
+        * @internal
+        */
+    export function unzipMVF(data: Uint8Array): Promise<RawMVF>;
+    export type LocalePackUrls = {
+            [key: string]: string;
+    };
+    /**
+        * Represents the environment state configuration.
+        * @example
+        * const mapData = getMapData({
+        *  key: '',
+        *  secret: '',
+        *  environment: 'eu'
+        * })
+        */
+    export type Environment = {
+            /**
+                * The base URI for the API.
+                */
+            baseUri: string;
+            /**
+                * The base URI for authentication.
+                */
+            baseAuthUri: string;
+            /**
+                * The base URI for analytics.
+                */
+            analyticsBaseUri: string;
+            /**
+                * The URI for the tile server.
+                */
+            tileServerUri: string;
+    };
+    type InternalServiceEnvironment = 'us' | 'eu' | 'us-staging-enterprise' | 'us-staging-self-serve';
+    export type ServiceEnvironment = 'us' | 'eu';
+    export function createEnvControl(): {
+            /**
+                * @internal
+                */
+            updateByUserOption(userOption: TGetMapDataOptions): void;
+            /**
+                * @internal
+                */
+            updateTileServerBaseUrl(url: string): void;
+            /**
+                * @internal
+                */
+            updateEnvironment(env: InternalServiceEnvironment): void;
+            getBaseUri(enterprise: boolean): string;
+            getBaseAuthUri(enterprise?: boolean): string;
+            getAnalyticsBaseUri(): string;
+            getTileServerUri(): string;
+            reset(): void;
+            /**
+                * @internal
+                */
+            __getState: () => Environment;
+    };
+    export type EnvControl = ReturnType<typeof createEnvControl>;
+    /**
+        * Return IDs for all individual maps that are part of a multi-building MVF, not including the
+        * outdoor map. If a map is not a multi-building map, an empty array is returned.
+        */
+    export const getBuildingIds: (mvf: ParsedMVF) => string[];
+}
+
+declare module '@mappedin/react-sdk/packages/mvf-utils/geometry' {
+    import type { EntranceFeature, ObstructionWallFeature } from '@mappedin/react-sdk/packages/mvf-utils/mvf-types';
+    export function findAndSplitObstructionByAllEntrances(wall: ObstructionWallFeature, entrances: EntranceFeature[]): {
+        entrances: EntranceFeature[];
+        obstructions: ObstructionWallFeature[];
+    };
+}
+
+declare module '@mappedin/react-sdk/mappedin-js/src/map-data-objects/node' {
+    import type { NodeCollection } from '@mappedin/mvf';
+    import Coordinate from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/coordinate';
+    import type { EnterpriseLocation, MapDataInternal, Space } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
+    import type Floor from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/floor';
+    import BaseMetaData from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/base-metadata-object';
+    import type { IGeoJSONData } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects/types';
+    import type { IAnchorable, IFocusable } from '@mappedin/react-sdk/mappedin-js/src/types';
+    /**
+        * A class representing {@link Path} node data within the map.
+        *
+        * Nodes are used to define points in the map's pathfinding graph.
+        *
+        */
+    class Node extends BaseMetaData implements IGeoJSONData, IFocusable, IAnchorable {
+            #private;
+            /**
+                * @internal
+                */
+            static readonly __type = "node";
+            /**
+                * @internal
+                */
+            readonly __type = "node";
+            /**
+                * Checks if the provided instance is of type Node.
+                *
                 * @param instance The instance to check.
                 * @returns {boolean} True if the instance is a Node, false otherwise.
                 */
@@ -6176,6 +7272,27 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-view-objects/path' {
     }
 }
 
+declare module '@mappedin/react-sdk/mappedin-js/src/utils/types' {
+    /**
+        * Utility type that extracts nested values matching a specific type
+        * @example
+        * type A = ExtractDeep<{ a: { b: string; c: number; }; d: string; e: number; }, number>;
+        * // { a: { c: number; } e: number; }
+        */
+    export type ExtractDeep<T, U> = {
+            [K in keyof T as T[K] extends U ? K : T[K] extends object | undefined ? ExtractDeep<NonNullable<T[K]>, U> extends never ? never : K : never]: T[K] extends object | undefined ? undefined extends T[K] ? ExtractDeep<NonNullable<T[K]>, U> | undefined : ExtractDeep<NonNullable<T[K]>, U> : T[K] extends U ? T[K] : never;
+    };
+    /**
+        * Makes all properties in an object (including nested ones) optional
+        * @example
+        * type A = DeepPartial<{ a: { b: string; c: number; }; d: string; }>;
+        * // { a?: { b?: string; c?: number; }; d?: string; }
+        */
+    export type DeepPartial<T> = T extends object ? {
+            [P in keyof T]?: DeepPartial<T[P]>;
+    } : T;
+}
+
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/types' {
     import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
     export type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
@@ -6189,6 +7306,7 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
     import type { CollisionRankingTier } from '@mappedin/react-sdk/geojson/src/utils/collision-ranking-tier';
     import { z } from 'zod';
     import { type PackedBBoxes } from '@mappedin/react-sdk/geojson/src/systems/collisions/system';
+    import type { GeometryState } from '@mappedin/react-sdk/geojson/src/components/mesh';
     /**
         * State reprsenting a Marker
         */
@@ -6221,32 +7339,12 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
                 * Pointer to the HTML element of the marker in the DOM tree
                 */
             element: HTMLElement;
-            /**
-                * The initial rank of the marker, which can be used to reset the rank of the marker to its initial value.
-                */
-            initialRank: CollisionRankingTier | number;
-            options?: {
-                    /**
-                        * The rank of the marker, which determines its visibility in relation to other colliders.
-                        */
-                    rank?: CollisionRankingTier | number;
-                    /**
-                        * Whether the Marker should be clickable via the SDK's internal click event system.
-                        *
-                        * @example
-                        * ```javascript
-                        * 	renderer.on('click', ({ markers }) => {});
-                        * ```
-                        */
-                    interactive?: boolean | 'pointer-events-auto';
-                    /**
-                        * The z-index of the marker. Can be used used in conjunction with rank: 'always-visible' to make certain markers appear over others
-                        */
-                    zIndex?: number;
-                    /**
-                        * The vertical position of the marker relative to the floor.
-                        */
-                    verticalOffset?: number;
+            /**
+                * The initial rank of the marker, which can be used to reset the rank of the marker to its initial value.
+                */
+            initialRank: CollisionRankingTier | number;
+            options: Omit<AddMarkerOptions, 'id'> & {
+                    lowPriorityPin: LowPriorityPinConfig;
             };
             /**
                 * Anchor point for the marker. This will determine the position of the marker relative to the position. A list will place the marker in the first empty placement.
@@ -6257,6 +7355,29 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
                 */
             dynamicResize: boolean;
     };
+    export type MarkerStateUpdate = Omit<MarkerState, 'type' | 'parent' | 'id' | 'options'> & {
+            options?: Partial<Omit<AddMarkerOptions, 'id' | 'lowPriorityPin'>>;
+    };
+    /**
+        * Configuration for the low priority pin fallback strategy
+        */
+    export type LowPriorityPinConfig = {
+            /**
+                * Whether to enable low priority pin strategy when all anchor positions have collisions.
+                * @default true
+                */
+            enabled: boolean;
+            /**
+                * Size of the low priority pin in pixels.
+                * @default 2
+                */
+            size: number;
+            /**
+                * Color of the low priority pin.
+                * @default '#666'
+                */
+            color: string;
+    };
     export const addMarkerOptionsSchema: z.ZodObject<{
             rank: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["low", "medium", "high", "always-visible"]>, z.ZodNumber]>>;
             interactive: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"pointer-events-auto">]>>;
@@ -6264,6 +7385,19 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
             anchor: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "bottom", "left", "right", "center", "top-left", "top-right", "bottom-left", "bottom-right"]>, z.ZodArray<z.ZodEnum<["top", "bottom", "left", "right", "center", "top-left", "top-right", "bottom-left", "bottom-right"]>, "many">]>>;
             dynamicResize: z.ZodOptional<z.ZodBoolean>;
             zIndex: z.ZodOptional<z.ZodNumber>;
+            lowPriorityPin: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                    size: z.ZodOptional<z.ZodNumber>;
+                    color: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                    size?: number | undefined;
+                    color?: string | undefined;
+                    enabled?: boolean | undefined;
+            }, {
+                    size?: number | undefined;
+                    color?: string | undefined;
+                    enabled?: boolean | undefined;
+            }>>;
     }, "strip", z.ZodTypeAny, {
             anchor?: "center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | ("center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right")[] | undefined;
             id?: string | undefined;
@@ -6271,6 +7405,11 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
             dynamicResize?: boolean | undefined;
             zIndex?: number | undefined;
             rank?: number | "low" | "medium" | "high" | "always-visible" | undefined;
+            lowPriorityPin?: {
+                    size?: number | undefined;
+                    color?: string | undefined;
+                    enabled?: boolean | undefined;
+            } | undefined;
     }, {
             anchor?: "center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | ("center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right")[] | undefined;
             id?: string | undefined;
@@ -6278,9 +7417,15 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
             dynamicResize?: boolean | undefined;
             zIndex?: number | undefined;
             rank?: number | "low" | "medium" | "high" | "always-visible" | undefined;
+            lowPriorityPin?: {
+                    size?: number | undefined;
+                    color?: string | undefined;
+                    enabled?: boolean | undefined;
+            } | undefined;
     }>;
     export function validateMarker(coordinate: Position, contentHTML: string, options: AddMarkerOptions): void;
     export type MarkerAnchor = 'top' | 'bottom' | 'left' | 'right' | 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    type InternalMarkerAnchor = MarkerAnchor | 'low-priority-pin';
     /**
         * Options for creating a new Marker
         */
@@ -6323,6 +7468,16 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
                 * The vertical position of the marker relative to the floor.
                 */
             verticalOffset?: number;
+            /**
+                * The entity to attach the marker to.
+                */
+            attachTo?: EntityId<GeometryState> | string | number | null;
+            /**
+                * Configuration for the low priority pin fallback strategy.
+                * When enabled, shows a smaller pin version of the marker when all anchor positions have collisions.
+                * @default { enabled: true, size: 2, color: '#666' }
+                */
+            lowPriorityPin?: Partial<LowPriorityPinConfig>;
     };
     export class MarkerComponent {
             id: string | number;
@@ -6330,9 +7485,11 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
             static testId: number;
             rank: number;
             initialRank: number;
-            activeAnchor: MarkerAnchor;
+            activeAnchor: InternalMarkerAnchor;
             pointerEvents: 'auto' | 'none';
-            options: Required<Omit<AddMarkerOptions, 'zIndex'>> & {
+            options: Required<Omit<AddMarkerOptions, 'zIndex' | 'attachTo'> & {
+                    lowPriorityPin: Required<LowPriorityPinConfig>;
+            }> & {
                     zIndex?: number;
             };
             projection: Vector2;
@@ -6351,8 +7508,9 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
                     w: number;
                     h: number;
             };
-            containerEl: Entity2DHTMLDivElement;
-            contentEl: HTMLDivElement | null;
+            markerContainer: Entity2DHTMLDivElement;
+            containerEl: HTMLElement;
+            contentEl: HTMLElement | null;
             contentHtml: string;
             style: {
                     top: string;
@@ -6360,7 +7518,7 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
             };
             dirty: boolean;
             /** Flag used in 2d-projection system to determine if the parent has changed */
-            parentDirty: boolean;
+            attachedDirty: boolean;
             collisionDirty: boolean;
             visibilityNeedsUpdate: 'show' | 'hide' | false;
             constructor(contentHtml: string, options?: AddMarkerOptions);
@@ -6369,7 +7527,7 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
             currentStrategyIndex: number;
             onStrategySelected: (strategyIndex: number, force?: boolean) => void;
             get strategies(): {
-                    name: MarkerAnchor;
+                    name: InternalMarkerAnchor;
                     getBoundingBox: () => number[];
             }[];
             toPackedMessage(isPanning?: boolean): {
@@ -6381,8 +7539,13 @@ declare module '@mappedin/react-sdk/geojson/src/components/marker' {
                     lockedToStrategyIndex: number;
                     shouldCollideWithScreenEdges: boolean;
             };
+            /**
+                * Get the index of the low priority pin strategy
+                */
+            get lowPriorityPinStrategyIndex(): number;
             destroy(): void;
     }
+    export {};
 }
 
 declare module '@mappedin/react-sdk/geojson/src/components/path' {
@@ -6990,6 +8153,10 @@ declare module '@mappedin/react-sdk/geojson/src/components/label' {
                 * The vertical position of the label relative to the floor.
                 */
             verticalOffset?: number;
+            /**
+                * The entity to attach the label to.
+                */
+            attachTo?: EntityId<GeometryState> | string | null;
     };
     type TStyle = {
             top?: number;
@@ -7132,7 +8299,7 @@ declare module '@mappedin/react-sdk/geojson/src/components/label' {
             totalMarkerSize: number;
             dirty: boolean;
             /** Flag used in 2d-projection system to determine if the parent has changed */
-            parentDirty: boolean;
+            attachedDirty: boolean;
             collisionDirty: boolean;
             lastTextAlign: any;
             imageHash?: number;
@@ -7177,9 +8344,11 @@ declare module '@mappedin/react-sdk/geojson/src/entities/group-container' {
     import type { BatchedText } from '@mappedin/react-sdk/geojson/src/services/text3d/text3d';
     import type { EntityTypes } from '@mappedin/react-sdk/geojson/src/renderer';
     import type { Feature, MultiPolygon, Polygon } from 'geojson';
+    import type { FocusableComponent } from '@mappedin/react-sdk/geojson/src/components/focusable';
     export enum GroupContainerComponents {
             Stack = 0,
-            Interaction = 1
+            Interaction = 1,
+            Focusable = 2
     }
     /**
         * State representing a Group Container, which is a container for other Group Containers, Geometry Groups, Labels, Markers and Paths.
@@ -7220,7 +8389,7 @@ declare module '@mappedin/react-sdk/geojson/src/entities/group-container' {
                     /** The effective opacity of the entity after all parent containers have been considered. */
                     computedOpacity: number;
             };
-            components: [StackComponent?, InteractionComponent?];
+            components: [StackComponent?, InteractionComponent?, FocusableComponent?];
             constructor(id: string);
             addOccluderFeature(feature: Feature<Polygon | MultiPolygon, any>, occluderId: number): void;
             addEntity(entityGroupOrContainer: GroupContainerObject3D | GeometryGroupObject3D | Geometry2D | Geometry3DTypes): void;
@@ -7239,6 +8408,7 @@ declare module '@mappedin/react-sdk/geojson/src/entities/geometry-group' {
     import { type GeometryState } from '@mappedin/react-sdk/geojson/src/components/mesh';
     import type { ModelState } from '@mappedin/react-sdk/geojson/src/components/model';
     import { GeometryGroupStyleComponent } from '@mappedin/react-sdk/geojson/src/components/geometry-group-style';
+    import type { MaterialSide } from '@mappedin/react-sdk/geojson/src/components/styles';
     export enum GeometryGroupComponents {
             GeometryGroupStyle = 0
     }
@@ -7310,6 +8480,10 @@ declare module '@mappedin/react-sdk/geojson/src/entities/geometry-group' {
                 * height of the geometry group
                 */
             height?: number;
+            /**
+                * Material side of the geometry group
+                */
+            side?: MaterialSide;
     };
     export type ChildUpdatable<T> = T extends LineStyle ? Partial<Pick<LineStyle, 'color' | 'opacity' | 'visible'>> : Partial<Pick<PaintStyle, 'color' | 'opacity' | 'visible'>>;
     export class GeometryGroupObject3D extends Object3D {
@@ -7322,7 +8496,6 @@ declare module '@mappedin/react-sdk/geojson/src/entities/geometry-group' {
                     modelURL?: string;
                     opacity: number;
                     dirty: boolean;
-                    outlineDirty: boolean;
                     shadingDirty: boolean;
             };
             setVisible(visible: boolean): void;
@@ -7417,6 +8590,7 @@ declare module '@mappedin/react-sdk/geojson/src/types' {
             showImage?: boolean;
             flipImageToFaceCamera?: boolean;
             side?: MaterialSide;
+            renderOrder?: number;
     };
     export type Shading = {
             start?: number;
@@ -7436,6 +8610,7 @@ declare module '@mappedin/react-sdk/geojson/src/types' {
             shading?: Shading;
             outline?: boolean;
             side?: MaterialSide;
+            renderOrder?: number;
     };
     export type Layer = {
             id: string;
@@ -7729,7 +8904,7 @@ declare module '@mappedin/react-sdk/geojson/src/types' {
 }
 
 declare module '@mappedin/react-sdk/geojson/src/components/mesh' {
-    import type { Texture, BufferGeometry, LineSegments, Mesh } from 'three';
+    import type { Texture, BufferGeometry, Mesh } from 'three';
     import { BatchedMesh, Color, Vector3 } from 'three';
     import type { BatchedStandardMaterial } from '@mappedin/react-sdk/geojson/src/systems/mesh-creation-and-optimization/batched-material';
     import type { EntityId, Position } from '@mappedin/react-sdk/geojson/src/types';
@@ -7851,7 +9026,6 @@ declare module '@mappedin/react-sdk/geojson/src/components/mesh' {
             #private;
             mesh?: EntityBatchedMesh;
             focusMesh?: Mesh;
-            outline?: LineSegments;
             imageMesh?: Mesh;
             /**
                 * holds a pointer to space label text if the polygon has label active.
@@ -8273,7 +9447,7 @@ declare module '@mappedin/react-sdk/geojson/src/renderer' {
     import { Renderer } from '@mappedin/react-sdk/geojson/src/services/renderer';
     import { CollisionSystem } from '@mappedin/react-sdk/geojson/src/systems/collisions/system';
     import { InteractionSystem } from '@mappedin/react-sdk/geojson/src/systems/interactions';
-    import type { AddMarkerOptions, MarkerState } from '@mappedin/react-sdk/geojson/src/components/marker';
+    import type { AddMarkerOptions, MarkerState, MarkerStateUpdate } from '@mappedin/react-sdk/geojson/src/components/marker';
     import type { GLTFExportOptions } from '@mappedin/react-sdk/geojson/src/systems/exporter';
     import { ExporterSystem } from '@mappedin/react-sdk/geojson/src/systems/exporter';
     import type { AddLabelOptions, LabelState } from '@mappedin/react-sdk/geojson/src/components/label';
@@ -8397,6 +9571,7 @@ declare module '@mappedin/react-sdk/geojson/src/renderer' {
                     visible?: boolean;
                     altitude?: number;
                     interactive?: boolean;
+                    focusable?: boolean;
             }, parent?: EntityId<GroupContainerState> | string | number | null): EntityId<GroupContainerState>;
             addStackContainer(id: string, style?: {
                     visible?: true;
@@ -8509,7 +9684,7 @@ declare module '@mappedin/react-sdk/geojson/src/renderer' {
                 */
             setState(object: Partial<Omit<MapViewState, 'type'>>): void;
             setState<T extends EntityId<LabelState>>(object: T | T['id'], state: Partial<LabelState>): void;
-            setState<T extends EntityId<MarkerState>>(object: T | T['id'], state: Partial<MarkerState>): void;
+            setState<T extends EntityId<MarkerState>>(object: T | T['id'], state: Partial<MarkerStateUpdate>): void;
             setState<T extends EntityId<GeometryGroupState>>(object: T | T['id'], state: Partial<GeometryGroupState>): void;
             setState<T extends EntityId<GroupContainerState>>(object: T | T['id'], state: Partial<GroupContainerState>): void;
             setState<T extends EntityId<GeometryState>>(object: T | T['id'], state: Partial<GeometryState>): void;
@@ -9324,8 +10499,8 @@ declare module '@mappedin/react-sdk/geojson/src/entities/utils' {
     export function updateIndividualGeometryTexture(entity: Geometry3D, update?: Pick<StyleComponent, 'texture' | 'topTexture'>): boolean;
     export function updateIndividualGeometryOpacity(entity: Geometry3D, update?: number): boolean;
     export function updateAltitude(entity: EntityTypes, update?: number): boolean;
-    export function updateOutline(entity: All3DTypes, update?: boolean): boolean;
-    export function updateFocusable(entity: Geometry3D, update?: boolean): boolean;
+    export function updateOutline(entity: All3DTypes, state: RendererState, update?: boolean): boolean;
+    export function updateFocusable(entity: Geometry3D | GroupContainerObject3D, update?: boolean): boolean;
     export function updateIndividualGeometryRenderOrder(entity: Geometry3D, update?: number): boolean;
     export function handlePathUpdate(geometry: Geometry3DTypes, state: RendererState, update: PathUpdateState): void;
     export function pickPathOptions(update: PathUpdateState): Partial<PathUpdateState>;
@@ -9454,19 +10629,85 @@ declare module '@mappedin/react-sdk/geojson/src/utils/constants' {
 
 declare module '@mappedin/react-sdk/geojson/src/utils/debug' {
     import type Core from '@mappedin/react-sdk/geojson/src/renderer';
+    /**
+        * Default debug state configuration with all debug features disabled by default.
+        */
     const DEFAULT_DEBUG_STATE: {
-        showPolygonLabelTextAreaMesh: boolean;
-        showEnvMap: boolean;
+            /** Shows the text area mesh used for polygon label rendering */
+            showPolygonLabelTextAreaMesh: boolean;
+            /** Enables the basic environment map for lighting and reflections */
+            showEnvMap: boolean;
+            /** Shows collision detection boxes for debugging spatial interactions */
+            showCollisionBoxes: boolean;
     };
+    /**
+        * Type definition for the debug state configuration.
+        * Represents all available debug options that can be toggled.
+        */
     export type DebugState = typeof DEFAULT_DEBUG_STATE;
+    /**
+        * Debug utility class for toggling various debug visualization features.
+        *
+        * This class provides a centralized way to control debug features like:
+        * - Text area mesh visualization for polygon labels
+        * - Environment map rendering
+        * - Collision box visualization
+        *
+        * @example
+        * ```typescript
+        * const debug = new Debug(core);
+        *
+        * // Enable collision boxes and environment map
+        * debug.update({
+        *   showCollisionBoxes: true,
+        *   showEnvMap: true
+        * });
+        *
+        * // Disable all debug features
+        * debug.update({
+        *   showCollisionBoxes: false,
+        *   showEnvMap: false,
+        *   showPolygonLabelTextAreaMesh: false
+        * });
+        * ```
+        */
     export class Debug {
-        state: {
-            showPolygonLabelTextAreaMesh: boolean;
-            showEnvMap: boolean;
-        };
-        core: Core;
-        constructor(core: Core);
-        update(updateState: Partial<DebugState>): void;
+            /** Current debug state configuration */
+            state: {
+                    /** Shows the text area mesh used for polygon label rendering */
+                    showPolygonLabelTextAreaMesh: boolean;
+                    /** Enables the basic environment map for lighting and reflections */
+                    showEnvMap: boolean;
+                    /** Shows collision detection boxes for debugging spatial interactions */
+                    showCollisionBoxes: boolean;
+            };
+            /** Reference to the core renderer instance */
+            core: Core;
+            /**
+                * Creates a new Debug instance.
+                *
+                * @param core - The core renderer instance to control debug features for
+                */
+            constructor(core: Core);
+            /**
+                * Updates the debug state with new configuration options.
+                * Only changed values will trigger updates to the corresponding systems.
+                *
+                * @param updateState - Partial debug state with the options to update
+                *
+                * @example
+                * ```typescript
+                * // Enable only collision boxes
+                * debug.update({ showCollisionBoxes: true });
+                *
+                * // Enable multiple features at once
+                * debug.update({
+                *   showEnvMap: true,
+                *   showPolygonLabelTextAreaMesh: true
+                * });
+                * ```
+                */
+            update(updateState: Partial<DebugState>): void;
     }
     export {};
 }
@@ -9586,9 +10827,13 @@ declare module '@mappedin/react-sdk/geojson/src/systems/text3d/system' {
             showTextAreaMesh(): void;
             hideTextAreaMesh(): void;
     }
+    export function configureWorker(useWorker: boolean): void;
     /**
         *  Preload fonts and optionally pre-generate the SDF textures for particular glyphs up front.
         *  This is to avoid ondemand font generation can take long.
+        *
+        *  If working in CSP-restricted environment, call `disableText3DWorker` before to avoid errors
+        *
         *  @param fontUrl - url of the font file served.
         *  @returns  A promise that resolves when the font is loaded
         *
@@ -9598,150 +10843,166 @@ declare module '@mappedin/react-sdk/geojson/src/systems/text3d/system' {
     export const DEFAULT_VERTICAL_OFFSET = 0.5;
 }
 
-declare module '@mappedin/react-sdk/geojson/src/systems/exporter' {
-    export { ExporterSystem, type GLTFExportOptions } from '@mappedin/react-sdk/geojson/src/systems/exporter/exporter';
-}
-
-declare module '@mappedin/react-sdk/geojson/src/systems/html-controls/system' {
-    import type { Map } from '@mappedin/react-sdk/packages/outdoor-context-v4';
-    import '../../styles/html-controls.scss';
-    /**
-        * All possible control anchor positions.
-        */
-    export const ATTRIBUTION_POSITIONS: readonly ["top-left", "top-right", "bottom-left", "bottom-right"];
-    export type AttributionPosition = (typeof ATTRIBUTION_POSITIONS)[number];
-    export type AttributionControlOptions = {
-            custom?: string[];
-            position?: AttributionPosition;
-            feedback?: boolean;
-    };
-    export class HTMLControlsSystem {
-            controlContainerEl: HTMLDivElement;
-            controlPositions: Record<AttributionPosition, HTMLDivElement>;
-            compact: boolean | undefined;
-            attribContainerEl?: HTMLDetailsElement;
-            attribInnerEl?: HTMLDivElement;
-            attribButtonEl?: HTMLElement;
-            feedbackLinkEl?: HTMLAnchorElement;
-            attribHTML: string;
-            customAttributions: string[];
-            constructor(container: HTMLElement);
-            addAttributionControl(options?: AttributionControlOptions): void;
-            toggleAttribution: (e: MouseEvent) => void;
-            destroyAttributionControl(): void;
-            resize(canvasWidth: number): void;
-            /**
-                * This should fire when Maplibre data changes.
-                */
-            updateData(map: Map): void;
-            destroy(): void;
-    }
-}
-
-declare module '@mappedin/react-sdk/geojson/src/components/styles' {
-    export { StyleComponent, DEFAULT_COLOR, type MaterialSide } from '@mappedin/react-sdk/geojson/src/components/styles/style';
-    export { Text3DStyleComponent, type Text3DStyle, DEFAULT_TEXT_STYLE } from '@mappedin/react-sdk/geojson/src/components/styles/text-style';
-    export { ModelStyleComponnet, type ModelStyle } from '@mappedin/react-sdk/geojson/src/components/styles/model-style';
-    export { DEFAULT_ROTATION, DEFAULT_SCALE } from '@mappedin/react-sdk/geojson/src/components/styles/constants';
-}
-
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/api' {
-    import type { RendererCore, WatermarkUpdateOptions } from '@mappedin/core-sdk';
-    import { type TShow3DMapOptions } from '@mappedin/react-sdk/mappedin-js/src';
-    import { WALLS, DOORS } from '@mappedin/react-sdk/mappedin-js/src/types';
-    import type MapData from '@mappedin/react-sdk/mappedin-js/src/map-data';
-    import type { FloorStack, MapDataInternal } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
-    import { Facade, Coordinate, MapObject, Space, Floor, Door } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
-    import type { MapView } from '@mappedin/react-sdk/mappedin-js/src/map-view';
-    import { Label, Marker, Shape } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
-    import { Text3D as Text3DView, Model, Path, type Image } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
-    import { Navigation } from '@mappedin/react-sdk/mappedin-js/src/navigation';
-    import type { TGetState, TUpdateState } from '@mappedin/react-sdk/mappedin-js/src/types';
-    import { Camera } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/camera';
-    import { Exporter } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/exporter';
-    import { Labels } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/labels';
-    import { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
-    import { Markers } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/markers';
-    import { Images } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/images';
-    import { Models } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/models';
-    import { Paths } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/paths';
-    import { BlueDot } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/blue-dot/blue-dot';
-    import type { TFloorChangeReason } from '@mappedin/react-sdk/mappedin-js/src/events';
-    import { Shapes } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/shapes';
-    import { Style } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/style';
-    import Outdoor from '@mappedin/react-sdk/mappedin-js/src/api-geojson/outdoor';
-    import { type BBox } from 'geojson';
-    import { Text3D } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/text3d';
-    import { PathSegment } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects/path';
-    export class GeoJsonApi {
-            core: RendererCore;
-            mapObjects: GeojsonApiMapObject[];
-            id: string;
-            mapDataExternal: {
-                    [key in string]: MapData;
-            };
-            mapData?: MapData;
-            currentMap: GeojsonApiMapObject;
-            hiddenOutdoorGeometries: [
-                    BBox,
-                    polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[],
-                    layers: string[]
-            ][];
-            mapView: MapView;
-            Camera: Camera;
-            Labels: Labels;
-            Text3D: Text3D;
-            Markers: Markers;
-            Models: Models;
-            Paths: Paths;
-            Exporter: Exporter;
-            Navigation: Navigation;
-            Outdoor: Outdoor;
-            BlueDot: BlueDot;
-            Shapes: Shapes;
-            Style: Style;
-            Images: Images;
-            get DynamicFocus(): import("..").DynamicFocus;
-            get StackedMaps(): import("..").StackedMaps;
-            constructor(rendererCore: RendererCore, mapView: MapView);
-            updateState<T extends Space | Text3DView | MapObject | Label | Shape | Marker | Model | Door | Facade | Floor | WALLS | DOORS | Path | PathSegment | (string & NonNullable<unknown>)>(target: T, state: TUpdateState<T>): void;
-            update: () => void;
-            getMapDataInternal(): MapDataInternal | undefined;
-            getMapData(): MapData | undefined;
-            addMap(mapData: MapData, options?: TShow3DMapOptions): Promise<MapData>;
-            setFloor(floor: Floor | string, reason?: TFloorChangeReason): void;
-            setFloorStack(floorStack: FloorStack | string): void;
-            updateWatermark(options: WatermarkUpdateOptions): void;
-            get currentFloorStack(): FloorStack;
-            get currentFloor(): Floor;
-            getState<T extends Space | Text3DView | MapObject | Label | Marker | Image | Shape | Model | Path | PathSegment | Floor | Facade | string>(target: T): TGetState<T>;
-            setHoverColor(c: string): void;
-            getHoverColor(): string | undefined;
-            /**
-                * Create a coordinate from a screen coordinate
-                * @param x - The x coordinate of the screen
-                * @param y - The y coordinate of the screen
-                * @param floor - The floor to use for the coordinate
-                * @returns The coordinate
-                */
-            createCoordinateFromScreenCoordinate(x: number, y: number, floor?: Floor): Coordinate | undefined;
-            getScreenCoordinateFromCoordinate(coordinate: Coordinate): {
+declare module '@mappedin/react-sdk/geojson/src/systems/collisions/system' {
+    import { QuadTree } from '@packages/internal/quad-tree';
+    import '../../styles/collisions.scss';
+    import type { MarkerComponent } from '@mappedin/react-sdk/geojson/src/components/marker';
+    import type LabelComponent from '@mappedin/react-sdk/geojson/src/components/label';
+    import { PubSub } from '@mappedin/react-sdk/packages/common/pubsub';
+    import type { RendererState } from '@mappedin/react-sdk/geojson/src/renderer';
+    import type { TSerializedCollider, TSerializedColliderResponse } from '@mappedin/react-sdk/geojson/src/systems/collisions/collider-processor';
+    import type { WatermarkPosition } from '@mappedin/react-sdk/geojson/src/systems/watermark/system';
+    export type TMessageEvent = MessageEvent<{
+            msgId: string;
+            colliders: TSerializedColliderResponse[];
+            debug: {
                     x: number;
                     y: number;
-            };
-            isInView(target: Space | MapObject | Label | Marker | string): boolean;
-            auto(): {
-                    labels: Label[];
-            };
+                    w: number;
+                    h: number;
+            }[];
+    }>;
+    export type TMessage = {
+            msgId: string;
+            totalWidth: number;
+            totalHeight: number;
+            watermarkWidth: number;
+            watermarkHeight: number;
+            watermarkPosition: WatermarkPosition;
+            colliders: TSerializedCollider[];
+            devicePixelRatio: number;
+    };
+    type TCollisionSystemEvent = {
+            'visibility-changed': undefined;
+    };
+    export type PackedBBox = [x: number, y: number, w: number, h: number, index: number];
+    export type PackedBBoxes = PackedBBox[];
+    export type PackedCollider = [
+            bboxes: PackedBBoxes,
+            enabled: 0 | 1,
+            alwaysVisible: 0 | 1,
+            x: number,
+            y: number,
+            shouldCollideWithScreenEdges?: 0 | 1,
+            onlyExposeStrategyIndex?: number
+    ];
+    export type PackedMessage = [
+            colliders: PackedCollider[],
+            devicePixelRatio: number,
+            totalHeight: number,
+            totalWidth: number,
+            watermarkWidth: number,
+            watermarkHeight: number,
+            watermarkPosition: WatermarkPosition
+    ];
+    export class CollisionSystem extends PubSub<TCollisionSystemEvent, keyof TCollisionSystemEvent> {
+            collidersDirty: boolean;
+            packedMessage: PackedMessage;
+            visibleCollidersQTree: QuadTree<{
+                    entityId: string | number;
+            }>;
+            interactiveCollidersQTree: QuadTree<{
+                    entityId: string | number;
+            }>;
+            coreState: RendererState;
+            constructor(debugCanvas: HTMLCanvasElement, coreState: RendererState, worker?: Worker);
+            postMessage: () => void;
+            showCollisionBoxes: () => void;
+            hideCollisionBoxes: () => void;
+            currentMsgId: string;
+            working: boolean;
+            componentArray: (MarkerComponent | LabelComponent)[];
+            update: (watermarkWidth: number, watermarkHeight: number, watermarkPosition?: WatermarkPosition, isPanning?: boolean) => void;
+            resize(watermarkWidth: number, watermarkHeight: number, watermarkPosition: WatermarkPosition): void;
+            /**
+                * Resolve collisions
+                */
+            resolve: (e: MessageEvent<{
+                    msgId: string;
+                    colliders: TSerializedColliderResponse[];
+            }>) => void;
+            drawDebug: () => void;
+            destroy: () => void;
+    }
+    /**
+        * Sets the URL for the collision system worker script.
+        *
+        * This function allows specifying a custom URL for the collision system's web worker,
+        * which is particularly useful in environments with strict Content Security Policy (CSP)
+        * that don't allow blob: URLs or inline scripts.
+        *
+        * When provided, the collision system will load its worker from the specified URL
+        * instead of creating an inline worker from a blob. This enables compatibility with
+        * environments that have restrictive CSP settings.
+        *
+        * @param url - The absolute URL pointing to the collision worker script.
+        *              This should be a URL where the compiled version of the worker.ts file is hosted.
+        *
+        * @example
+        * ```typescript
+        * // Set a custom URL for the collision worker
+        * import { setWorkerUrl } from '@mappedin/core-sdk';
+        *
+        * // Must be called before initializing any maps
+        * setWorkerUrl('https://cdn.example.com/workers/collision-worker.js');
+        * ```
+        *
+        * @remarks
+        * - This function must be called before any map instances are created
+        * - The worker file must be built and hosted separately as part of your deployment process
+        * - Ideal for applications that need to comply with strict CSP requirements
+        */
+    export function setWorkerUrl(url: string): void;
+    export {};
+}
+
+declare module '@mappedin/react-sdk/geojson/src/systems/exporter' {
+    export { ExporterSystem, type GLTFExportOptions } from '@mappedin/react-sdk/geojson/src/systems/exporter/exporter';
+}
+
+declare module '@mappedin/react-sdk/geojson/src/systems/html-controls/system' {
+    import type { Map } from '@mappedin/react-sdk/packages/outdoor-context-v4';
+    import '../../styles/html-controls.scss';
+    /**
+        * All possible control anchor positions.
+        */
+    export const ATTRIBUTION_POSITIONS: readonly ["top-left", "top-right", "bottom-left", "bottom-right"];
+    export type AttributionPosition = (typeof ATTRIBUTION_POSITIONS)[number];
+    export type AttributionControlOptions = {
+            custom?: string[];
+            position?: AttributionPosition;
+            feedback?: boolean;
+    };
+    export class HTMLControlsSystem {
+            controlContainerEl: HTMLDivElement;
+            controlPositions: Record<AttributionPosition, HTMLDivElement>;
+            compact: boolean | undefined;
+            attribContainerEl?: HTMLDetailsElement;
+            attribInnerEl?: HTMLDivElement;
+            attribButtonEl?: HTMLElement;
+            feedbackLinkEl?: HTMLAnchorElement;
+            attribHTML: string;
+            customAttributions: string[];
+            constructor(container: HTMLElement);
+            addAttributionControl(options?: AttributionControlOptions): void;
+            toggleAttribution: (e: MouseEvent) => void;
+            destroyAttributionControl(): void;
+            resize(canvasWidth: number): void;
             /**
-                * @internal
+                * This should fire when Maplibre data changes.
                 */
-            get __core(): RendererCore;
-            clear(): void;
+            updateData(map: Map): void;
             destroy(): void;
     }
 }
 
+declare module '@mappedin/react-sdk/geojson/src/components/styles' {
+    export { StyleComponent, DEFAULT_COLOR, type MaterialSide } from '@mappedin/react-sdk/geojson/src/components/styles/style';
+    export { Text3DStyleComponent, type Text3DStyle, DEFAULT_TEXT_STYLE } from '@mappedin/react-sdk/geojson/src/components/styles/text-style';
+    export { ModelStyleComponnet, type ModelStyle } from '@mappedin/react-sdk/geojson/src/components/styles/model-style';
+    export { DEFAULT_ROTATION, DEFAULT_SCALE } from '@mappedin/react-sdk/geojson/src/components/styles/constants';
+}
+
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object' {
     import type { ParsedMVF } from '@mappedin/mvf';
     import type { FeatureCollection, LineString, MultiPolygon, Polygon } from 'geojson';
@@ -9753,12 +11014,11 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object' {
     import { type AggregatedStyleMap } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/utils';
     import { StackedMaps } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/stacked-maps/stacked-maps';
     import type { TFloorChangeReason } from '@mappedin/react-sdk/mappedin-js/src/events';
-    import type { Path, Shape, Label } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
+    import type { Path, Shape } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
     import type { MapDataInternal } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     import { Space, Coordinate } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     import { type GeoJsonApi } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/api';
     import { FloorStackObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-stack-object';
-    import { DynamicFocus } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/dynamic-focus';
     import type { Text3DState } from '@mappedin/core-sdk/src/components/text3d';
     export class GeojsonApiMapObject extends PubSub<{
         'floor-change': {
@@ -9794,7 +11054,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object' {
         options: TShow3DMapOptions;
         styleMap: AggregatedStyleMap;
         StackedMaps: StackedMaps;
-        DynamicFocus: DynamicFocus;
         get currentFloorStack(): FloorStackObject;
         setFloorStack(floorStackId: string, reason?: TFloorChangeReason): void;
         get currentFloor(): FloorObject;
@@ -9817,7 +11076,9 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object' {
             removeAll: () => void;
         };
         Markers: {
-            add: (coordinate: Coordinate, html: string, opts: TAddMarkerOptions) => EntityId<MarkerState> | undefined;
+            add: (coordinate: Coordinate, html: string, opts: TAddMarkerOptions & {
+                attachTo?: string;
+            }) => EntityId<MarkerState>;
             remove: (id: string) => void;
             getContentEl: (id: string) => HTMLElement | undefined;
             removeAll: () => void;
@@ -9844,14 +11105,12 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object' {
                 labelOptions?: TAddLabelOptions;
             }) => void;
             add: (coordinate: Coordinate, text: string, opts?: AddLabelOptions & {
-                floorId?: string;
-                parentId?: string;
+                attachTo?: string;
                 verticalOffset?: number;
             }) => {
                 id: string | number;
             };
-            remove: ({ label, entityId }: {
-                label: Label;
+            remove: ({ entityId }: {
                 entityId: string;
             }) => void;
             removeAll: () => void;
@@ -10308,7 +11567,44 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/camera' {
                 * @param options Optional settings for the camera animation.
                 */
             animateElevation(elevation: number, options?: TCameraAnimationOptions): Promise<void>;
+            /**
+                * @internal
+                * @experimental
+                * Force an update of the facades in view.
+                */
+            updateFacadesInView(): void;
+    }
+}
+
+declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/exporter' {
+    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
+    import type { GLTFExportOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
+    /**
+        * API to export the scene.
+        *
+        * @hidden
+        */
+    export class Exporter {
+            #private;
+            /**
+                * @internal
+                */
+            get currentMap(): GeojsonApiMapObject | undefined;
+            /**
+                * @internal
+                */
+            constructor({ currentMapGetter }: {
+                    currentMapGetter: CurrentMapGetter;
+            });
+            /**
+                * Exports the current scene as a GLTF file.
+                *
+                * @hidden
+                */
+            getCurrentSceneGLTF(userOptions: GLTFExportOptions): Promise<Blob>;
     }
+    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
+    export {};
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/labels' {
@@ -10473,6 +11769,80 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/markers' {
     export {};
 }
 
+declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/images' {
+    import type { IAnchorable, TAddImageOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
+    import { Image } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
+    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
+    /**
+        * Images can enhance the fidelity of an indoor map. They can be used to add custom branding, highlight important features, or provide additional information to users.
+        * Images can be placed on any {@link Door}, {@link Space}, or {@link Coordinate} on the map and given a verticalOffset to control the height at which the image is displayed.
+        *
+        * This class is accessed using {@link MapView.Images}.
+        *
+        * JPEG and PNG images are supported. It's important to consider the size of all unique image files displayed on a map at one time.
+        * Using many unique images may cause instability on mobile devices with limited GPU memory. The Mappedin SDK will cache and reuse images that have the same URL, resulting in reduced memory usage.
+        *
+        * The following calculations illustrates how much memory is used for a given image:
+        *
+        * Formula: `width * height * 4 bytes/pixel = memory used`
+        *
+        * 512 x 512 Pixel Image: `512px * 512px * 4 bytes/pixel = 1MB`
+        *
+        * 4096 x 4096 Pixel Image: `4096px * 4096px * 4 bytes/pixel = 64MB`
+        *
+        *  Refer to the [Images Guide](https://developer.mappedin.com/web-sdk/images-textures) for more information and interactive examples.
+        */
+    export class Images {
+            #private;
+            /**
+                * @internal
+                */
+            get currentMap(): GeojsonApiMapObject | undefined;
+            /**
+                * @internal
+                */
+            constructor({ currentMapGetter }: {
+                    currentMapGetter: CurrentMapGetter;
+            });
+            /**
+                * @internal
+                */
+            getById(id: string): {
+                    image: Image;
+                    entityId: string;
+            } | undefined;
+            /**
+                * Adds an image to the map.
+                *
+                * @param target The target object ({@link IAnchorable}) for the image.
+                * @param url The URL of the image.
+                * @param options Optional additional options for the {@link Image}.
+                * @returns {Image | undefined} The created {@link Image}, or undefined if creation failed.
+                * @example
+                * // Add an interactive {@link Image} to the map with custom HTML content.
+                * mapView.Images.add(coordinate, '<div>Image Content</div>', { interactive: true });
+                */
+            add(target: IAnchorable, url: string, options: TAddImageOptions): Image;
+            /**
+                * Removes a image from the map.
+                *
+                * @param image {Image} The {@link Image} which should be removed.
+                * @example
+                * mapView.Images.remove(image);
+                */
+            remove(image: Image): void;
+            /**
+                * Remove all the images from the map.
+                *
+                * @example
+                * mapView.Images.removeAll();
+                */
+            removeAll(): Image[];
+    }
+    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
+    export {};
+}
+
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/models' {
     import type { TAddModelOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
     import { Model } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
@@ -10559,59 +11929,148 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/paths' {
         *
         * Paths is accessed using {@link MapView.Paths}.
         *
-        * Paths can be drawn from one coordinate to another using {@link Paths.add}. If using just two coordinates, the path will be drawn straight between the two points.
-        * This may work for some scenarios, but in most cases an app will need to show the user their walking path, going through doors and avoiding walls and other objects.
-        * Such a path of coordinates can be created by calling the {@link MapData.getDirections} method, passing in a start and end {@link TNavigationTarget}. Note that a Space requires an entrance to be used as a target.
+        * Paths can be drawn from one coordinate to another using {@link Paths.add}. If using just two coordinates, the path will be drawn straight between the two points.
+        * This may work for some scenarios, but in most cases an app will need to show the user their walking path, going through doors and avoiding walls and other objects.
+        * Such a path of coordinates can be created by calling the {@link MapData.getDirections} method, passing in a start and end {@link TNavigationTarget}. Note that a Space requires an entrance to be used as a target.
+        *
+        * The width of the path is set using the {@link TAddPathOptions.nearRadius} and {@link TAddPathOptions.farRadius} parameters. These values are in meters. `nearRadius` is the path width used at the lowest zoom level closest to the ground and `farRadius` is used at the highest zoom level. Additional path styles are outlined later in this guide in the Path Styles section.
+        *
+        * Refer to the [Drawing a Path](https://developer.mappedin.com/web-sdk/wayfinding#drawing-a-path) in the Wayfinding Guide for more information and interactive examples.
+        */
+    export class Paths {
+            #private;
+            /**
+                * @internal
+                */
+            get currentMap(): GeojsonApiMapObject | undefined;
+            /**
+                * @internal
+                */
+            constructor({ currentMapGetter }: {
+                    currentMapGetter: CurrentMapGetter;
+            });
+            /**
+                * @internal
+                */
+            getById(id: string): {
+                    path: Path;
+                    entityIds: string[];
+            } | undefined;
+            /**
+                * Adds a path ({@link Path}) to the map.
+                * @param coordinate Array of coordinates ({@link Coordinate}) to form the path.
+                * @param options Optional additional option
+                * @example
+                * // Add a red path to the map
+                * mapView.Paths.add(coordinate,  { color: '#ff0000' });
+                */
+            add(coordinate: Coordinate[], options?: TAddPathOptions): Path;
+            /**
+                * Removes a specific path ({@link Path}) from the map.
+                * @param path The path to be removed.
+                * @example
+                * mapView.Paths.remove(path);
+                */
+            remove(path: Path): void;
+            /**
+                * Removes all paths ({@link Path}) from the map.
+                *
+                * @example
+                * mapView.Paths.removeAll();
+                */
+            removeAll(): Path[];
+    }
+    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
+    export {};
+}
+
+declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/style' {
+    import type { StyleCollection } from '@mappedin/mvf';
+    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
+    export class Style {
+            #private;
+            /**
+                * @internal
+                */
+            get currentMap(): GeojsonApiMapObject | undefined;
+            /**
+                * @internal
+                */
+            constructor({ currentMapGetter }: {
+                    currentMapGetter: CurrentMapGetter;
+            });
+            setFromStyleCollection(styleCollection: StyleCollection): void;
+    }
+    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
+    export {};
+}
+
+declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/outdoor' {
+    import { type RendererCore } from '@mappedin/core-sdk';
+    import type { BBox } from 'geojson';
+    export type HiddenOutdoorGeometry = [
+            BBox,
+            polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[],
+            layers: string[]
+    ];
+    /**
+        * The outdoor map shown around the Mappedin indoor map can be manipulated to show or hide additional information. It can be used to add GeoJSON based geometry, images, deck.gl layers and more.
+        *
+        * The outdoor map is accessed using {@link MapView.Outdoor.map}, which returns a maplibregl.Map object.
+        * [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.
         *
-        * The width of the path is set using the {@link TAddPathOptions.nearRadius} and {@link TAddPathOptions.farRadius} parameters. These values are in meters. `nearRadius` is the path width used at the lowest zoom level closest to the ground and `farRadius` is used at the highest zoom level. Additional path styles are outlined later in this guide in the Path Styles section.
+        * 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.
         *
-        * Refer to the [Drawing a Path](https://developer.mappedin.com/web-sdk/wayfinding#drawing-a-path) in the Wayfinding Guide for more information and interactive examples.
+        * Refer to the [Outdoor Map Guide](https://developer.mappedin.com/web-sdk/outdoor-map) for more information and interactive examples.
         */
-    export class Paths {
+    export default class Outdoor {
             #private;
             /**
                 * @internal
                 */
-            get currentMap(): GeojsonApiMapObject | undefined;
+            constructor(core: RendererCore, hiddenOutdoorGeometry?: HiddenOutdoorGeometry[]);
             /**
-                * @internal
+                * Set the style of the outdoor map. Use one of [Mappedin's predefined styles](https://developer.mappedin.com/web-sdk/outdoor-map#styles) or link to a custom style.
+                * @param style {any}
                 */
-            constructor({ currentMapGetter }: {
-                    currentMapGetter: CurrentMapGetter;
-            });
+            setStyle(style: any): void;
             /**
-                * @internal
+                * Returns a Maplibre map for advanced usage.
+                *
+                * @returns {object} Maplibre map instance
+                *
+                * Limitations:
+                * - 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.
                 */
-            getById(id: string): {
-                    path: Path;
-                    entityIds: string[];
-            } | undefined;
+            get map(): import("@packages/internal/outdoor-context-v4").Map | undefined;
             /**
-                * Adds a path ({@link Path}) to the map.
-                * @param coordinate Array of coordinates ({@link Coordinate}) to form the path.
-                * @param options Optional additional option
-                * @example
-                * // Add a red path to the map
-                * mapView.Paths.add(coordinate,  { color: '#ff0000' });
+                * Whether the outdoorView is enabled.
                 */
-            add(coordinate: Coordinate[], options?: TAddPathOptions): Path;
+            get enabled(): boolean;
             /**
-                * Removes a specific path ({@link Path}) from the map.
-                * @param path The path to be removed.
-                * @example
-                * mapView.Paths.remove(path);
+                * Whether the outdoorView is visible.
                 */
-            remove(path: Path): void;
+            get visible(): boolean;
             /**
-                * Removes all paths ({@link Path}) from the map.
-                *
-                * @example
-                * mapView.Paths.removeAll();
+                * Show the outdoor map.
                 */
-            removeAll(): Path[];
+            show(): void;
+            /**
+                * Hide the outdoor map.
+                * @param excludedStyleLayerIds {string[]}
+                */
+            hide(excludedStyleLayerIds?: string[]): void;
+            /**
+                * Set outdoor view opacity.
+                * @param targetOpacity {number | 'initial'}
+                * @param excludedStyleLayerIds {string[]}
+                */
+            setOpacity(targetOpacity: number | 'initial', excludedStyleLayerIds?: string[]): void;
     }
-    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
-    export {};
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/navigation/index' {
@@ -10709,6 +12168,11 @@ declare module '@mappedin/react-sdk/mappedin-js/src/navigation/index' {
                         */
                     animateArrowsOnPath?: boolean;
             };
+            /**
+                * Controls whether the path drawing is animated across floors.
+                * @default true
+                */
+            animatePathDrawing?: boolean;
             /**
                 * Options for the path.
                 */
@@ -10831,242 +12295,44 @@ declare module '@mappedin/react-sdk/mappedin-js/src/navigation/index' {
                 */
             get activePath(): Path | undefined;
             /**
-                * The current list of floor stacks along the navigation paths.
-                */
-            get floorStacks(): FloorStack[];
-            /**
-                * The current list of floors along the navigation paths.
-                */
-            get floors(): Floor[];
-            /**
-                * Sets the active path by index.
-                */
-            setActivePathByIndex(target: number): void;
-            /**
-                * Sets the active path.
-                */
-            setActivePath(target: Path): void;
-            /**
-                * Sets the active path by directions.
-                */
-            setActivePathByDirections(target: Directions): void;
-            /**
-                * @internal
-                */
-            drawSync(directions: Directions | Directions[], options?: TNavigationOptions): void;
-            /**
-                * Draws the specified directions on the map.
-                * @param directions The directions to be drawn.
-                * @param options Optional additional options for the navigation.
-                */
-            draw(directions: Directions | Directions[], options?: TNavigationOptions): Promise<unknown>;
-            /**
-                * Clears any drawn navigation paths or directions from the map.
-                */
-            clear(): void;
-    }
-    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
-    export {};
-}
-
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/exporter' {
-    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
-    import type { GLTFExportOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
-    /**
-        * API to export the scene.
-        *
-        * @hidden
-        */
-    export class Exporter {
-            #private;
-            /**
-                * @internal
-                */
-            get currentMap(): GeojsonApiMapObject | undefined;
-            /**
-                * @internal
-                */
-            constructor({ currentMapGetter }: {
-                    currentMapGetter: CurrentMapGetter;
-            });
-            /**
-                * Exports the current scene as a GLTF file.
-                *
-                * @hidden
-                */
-            getCurrentSceneGLTF(userOptions: GLTFExportOptions): Promise<Blob>;
-    }
-    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
-    export {};
-}
-
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/style' {
-    import type { StyleCollection } from '@mappedin/mvf';
-    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
-    export class Style {
-            #private;
-            /**
-                * @internal
-                */
-            get currentMap(): GeojsonApiMapObject | undefined;
-            /**
-                * @internal
-                */
-            constructor({ currentMapGetter }: {
-                    currentMapGetter: CurrentMapGetter;
-            });
-            setFromStyleCollection(styleCollection: StyleCollection): void;
-    }
-    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
-    export {};
-}
-
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/outdoor' {
-    import { type RendererCore } from '@mappedin/core-sdk';
-    import type { BBox } from 'geojson';
-    export type HiddenOutdoorGeometry = [
-            BBox,
-            polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[],
-            layers: string[]
-    ];
-    /**
-        * The outdoor map shown around the Mappedin indoor map can be manipulated to show or hide additional information. It can be used to add GeoJSON based geometry, images, deck.gl layers and more.
-        *
-        * The outdoor map is accessed using {@link MapView.Outdoor.map}, which returns a maplibregl.Map object.
-        * [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.
-        *
-        * 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.
-        *
-        * Refer to the [Outdoor Map Guide](https://developer.mappedin.com/web-sdk/outdoor-map) for more information and interactive examples.
-        */
-    export default class Outdoor {
-            #private;
-            /**
-                * @internal
-                */
-            constructor(core: RendererCore, hiddenOutdoorGeometry?: HiddenOutdoorGeometry[]);
-            /**
-                * Set the style of the outdoor map. Use one of [Mappedin's predefined styles](https://developer.mappedin.com/web-sdk/outdoor-map#styles) or link to a custom style.
-                * @param style {any}
-                */
-            setStyle(style: any): void;
-            /**
-                * Returns a Maplibre map for advanced usage.
-                *
-                * @returns {object} Maplibre map instance
-                *
-                * Limitations:
-                * - 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.
-                */
-            get map(): import("@packages/internal/outdoor-context-v4").Map | undefined;
-            /**
-                * Whether the outdoorView is enabled.
-                */
-            get enabled(): boolean;
-            /**
-                * Whether the outdoorView is visible.
-                */
-            get visible(): boolean;
-            /**
-                * Show the outdoor map.
-                */
-            show(): void;
-            /**
-                * Hide the outdoor map.
-                * @param excludedStyleLayerIds {string[]}
-                */
-            hide(excludedStyleLayerIds?: string[]): void;
-            /**
-                * Set outdoor view opacity.
-                * @param targetOpacity {number | 'initial'}
-                * @param excludedStyleLayerIds {string[]}
-                */
-            setOpacity(targetOpacity: number | 'initial', excludedStyleLayerIds?: string[]): void;
-    }
-}
-
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/images' {
-    import type { IAnchorable, TAddImageOptions } from '@mappedin/react-sdk/mappedin-js/src/types';
-    import { Image } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
-    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
-    /**
-        * Images can enhance the fidelity of an indoor map. They can be used to add custom branding, highlight important features, or provide additional information to users.
-        * Images can be placed on any {@link Door}, {@link Space}, or {@link Coordinate} on the map and given a verticalOffset to control the height at which the image is displayed.
-        *
-        * This class is accessed using {@link MapView.Images}.
-        *
-        * JPEG and PNG images are supported. It's important to consider the size of all unique image files displayed on a map at one time.
-        * Using many unique images may cause instability on mobile devices with limited GPU memory. The Mappedin SDK will cache and reuse images that have the same URL, resulting in reduced memory usage.
-        *
-        * The following calculations illustrates how much memory is used for a given image:
-        *
-        * Formula: `width * height * 4 bytes/pixel = memory used`
-        *
-        * 512 x 512 Pixel Image: `512px * 512px * 4 bytes/pixel = 1MB`
-        *
-        * 4096 x 4096 Pixel Image: `4096px * 4096px * 4 bytes/pixel = 64MB`
-        *
-        *  Refer to the [Images Guide](https://developer.mappedin.com/web-sdk/images-textures) for more information and interactive examples.
-        */
-    export class Images {
-            #private;
-            /**
-                * @internal
+                * The current list of floor stacks along the navigation paths.
                 */
-            get currentMap(): GeojsonApiMapObject | undefined;
+            get floorStacks(): FloorStack[];
             /**
-                * @internal
+                * The current list of floors along the navigation paths.
                 */
-            constructor({ currentMapGetter }: {
-                    currentMapGetter: CurrentMapGetter;
-            });
+            get floors(): Floor[];
             /**
-                * @internal
+                * Sets the active path by index.
                 */
-            getById(id: string): {
-                    image: Image;
-                    entityId: string;
-            } | undefined;
+            setActivePathByIndex(target: number): void;
             /**
-                * Adds an image to the map.
-                *
-                * @param target The target object ({@link IAnchorable}) for the image.
-                * @param url The URL of the image.
-                * @param options Optional additional options for the {@link Image}.
-                * @returns {Image | undefined} The created {@link Image}, or undefined if creation failed.
-                * @example
-                * // Add an interactive {@link Image} to the map with custom HTML content.
-                * mapView.Images.add(coordinate, '<div>Image Content</div>', { interactive: true });
+                * Sets the active path.
                 */
-            add(target: IAnchorable, url: string, options: TAddImageOptions): Image;
+            setActivePath(target: Path): void;
             /**
-                * Removes a image from the map.
-                *
-                * @param image {Image} The {@link Image} which should be removed.
-                * @example
-                * mapView.Images.remove(image);
+                * Sets the active path by directions.
                 */
-            remove(image: Image): void;
+            setActivePathByDirections(target: Directions): void;
             /**
-                * Remove all the images from the map.
-                *
-                * @example
-                * mapView.Images.removeAll();
+                * @internal
                 */
-            removeAll(): Image[];
+            drawSync(directions: Directions | Directions[], options?: TNavigationOptions): void;
+            /**
+                * Draws the specified directions on the map.
+                * @param directions The directions to be drawn.
+                * @param options Optional additional options for the navigation.
+                */
+            draw(directions: Directions | Directions[], options?: TNavigationOptions): Promise<unknown>;
+            /**
+                * Clears any drawn navigation paths or directions from the map.
+                */
+            clear(): void;
     }
     type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
     export {};
 }
 
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/dynamic-focus' {
-    export { DynamicFocus } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/dynamic-focus/dynamic-focus';
-}
-
 declare module '@mappedin/react-sdk/mappedin-js/src/search/internal' {
     import type { SearchResult as MiniSearchResult, Suggestion, MatchInfo } from 'minisearch';
     import type { Places } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
@@ -11646,6 +12912,60 @@ declare module '@mappedin/react-sdk/mappedin-js/src/analytics/customer' {
     export {};
 }
 
+declare module '@mappedin/react-sdk/packages/mvf-utils/tokens/access-token' {
+    import { type TGetMapDataWithCredentialsOptions } from '@mappedin/react-sdk/packages/mvf-utils/mvf-utils';
+    export const ACCESS_TOKEN_REFRESH_BUFFER_MINUTES = 60;
+    export const ACCESS_TOKEN_REFRESH_BUFFER_MS: number;
+    export const ACCESS_TOKEN_STORAGE_KEY = "accessTokens";
+    type AccessToken = {
+            accessToken: string;
+            expiresTimestamp: number;
+    };
+    type TGetAccessTokenOptions = Pick<TGetMapDataWithCredentialsOptions, 'baseUri' | 'baseAuthUri' | 'key' | 'secret'>;
+    /**
+        * Get an access token from storage or fetch it from the API using API keys.
+        */
+    export function getAccessToken(userOptions: TGetAccessTokenOptions, enterprise?: boolean): Promise<AccessToken>;
+    /**
+        * Fetch an access token for enterprise.
+        */
+    export function fetchAccessTokenEnterprise(userOptions: TGetAccessTokenOptions, currentTimestamp: number): Promise<AccessToken>;
+    export {};
+}
+
+declare module '@mappedin/react-sdk/packages/mvf-utils/tokens/sas-token' {
+    export const SAS_TOKEN_REFRESH_BUFFER_MINUTES = 60;
+    export const SAS_TOKEN_REFRESH_BUFFER_MS: number;
+    export const SAS_TOKEN_STORAGE_KEY = "miSasTokens";
+    type SasToken = {
+            token: string;
+            expires: number;
+    };
+    /**
+        * Fetch the SAS Token either from sesion storage or from the API using the access token.
+        * @param userOptions - The user options.
+        * @returns The SAS Token.
+        */
+    export function getSasToken(userOptions: {
+            mapId: string;
+            baseUri?: string;
+    }, accessToken: string): Promise<SasToken>;
+    /**
+        * Fetch the SAS Token for private images using the access token.
+        * @param userOptions - The user options.
+        * @param accessToken - The access token.
+        * @returns The SAS Token.
+        */
+    export function fetchSasToken(userOptions: {
+            mapId: string;
+            baseUri?: string;
+    }, accessToken: string): Promise<{
+            token: string;
+            expires: number;
+    }>;
+    export {};
+}
+
 declare module '@mappedin/react-sdk/mappedin-js/src/map-data-objects/base-metadata-object' {
     export default abstract class BaseMetaData {
         /**
@@ -11746,90 +13066,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src/map-data-objects/opening-hou
     }
 }
 
-declare module '@mappedin/react-sdk/geojson/src/systems/collisions/system' {
-    import { QuadTree } from '@packages/internal/quad-tree';
-    import '../../styles/collisions.scss';
-    import type { MarkerComponent } from '@mappedin/react-sdk/geojson/src/components/marker';
-    import type LabelComponent from '@mappedin/react-sdk/geojson/src/components/label';
-    import { PubSub } from '@mappedin/react-sdk/packages/common/pubsub';
-    import type { RendererState } from '@mappedin/react-sdk/geojson/src/renderer';
-    import type { TSerializedCollider, TSerializedColliderResponse } from '@mappedin/react-sdk/geojson/src/systems/collisions/collider-processor';
-    import type { WatermarkPosition } from '@mappedin/react-sdk/geojson/src/systems/watermark/system';
-    export type TMessageEvent = MessageEvent<{
-        msgId: string;
-        colliders: TSerializedColliderResponse[];
-        debug: {
-            x: number;
-            y: number;
-            w: number;
-            h: number;
-        }[];
-    }>;
-    export type TMessage = {
-        msgId: string;
-        totalWidth: number;
-        totalHeight: number;
-        watermarkWidth: number;
-        watermarkHeight: number;
-        watermarkPosition: WatermarkPosition;
-        colliders: TSerializedCollider[];
-        devicePixelRatio: number;
-    };
-    type TCollisionSystemEvent = {
-        'visibility-changed': undefined;
-    };
-    export type PackedBBox = [x: number, y: number, w: number, h: number, index: number];
-    export type PackedBBoxes = PackedBBox[];
-    export type PackedCollider = [
-        bboxes: PackedBBoxes,
-        enabled: 0 | 1,
-        alwaysVisible: 0 | 1,
-        x: number,
-        y: number,
-        shouldCollideWithScreenEdges?: 0 | 1,
-        onlyExposeStrategyIndex?: number
-    ];
-    export type PackedMessage = [
-        colliders: PackedCollider[],
-        devicePixelRatio: number,
-        totalHeight: number,
-        totalWidth: number,
-        watermarkWidth: number,
-        watermarkHeight: number,
-        watermarkPosition: WatermarkPosition
-    ];
-    export class CollisionSystem extends PubSub<TCollisionSystemEvent, keyof TCollisionSystemEvent> {
-        collidersDirty: boolean;
-        packedMessage: PackedMessage;
-        visibleCollidersQTree: QuadTree<{
-            entityId: string | number;
-        }>;
-        interactiveCollidersQTree: QuadTree<{
-            entityId: string | number;
-        }>;
-        coreState: RendererState;
-        constructor(debugCanvas: HTMLCanvasElement, coreState: RendererState, worker?: Worker);
-        postMessage: () => void;
-        showCollisionBoxes: () => void;
-        hideCollisionBoxes: () => void;
-        currentMsgId: string;
-        working: boolean;
-        componentArray: (MarkerComponent | LabelComponent)[];
-        update: (watermarkWidth: number, watermarkHeight: number, watermarkPosition?: WatermarkPosition, isPanning?: boolean) => void;
-        resize(watermarkWidth: number, watermarkHeight: number, watermarkPosition: WatermarkPosition): void;
-        /**
-          * Resolve collisions
-          */
-        resolve: (e: MessageEvent<{
-            msgId: string;
-            colliders: TSerializedColliderResponse[];
-        }>) => void;
-        drawDebug: () => void;
-        destroy: () => void;
-    }
-    export {};
-}
-
 declare module '@mappedin/react-sdk/geojson/src/entities/geometry3d' {
     import { Object3D } from 'three';
     import type { Mesh, Object3DEventMap, ShaderMaterial, Texture, TubeGeometry, Color, Vector2, Raycaster } from 'three';
@@ -11845,10 +13081,12 @@ declare module '@mappedin/react-sdk/geojson/src/entities/geometry3d' {
     import { GeometryGroupObject3D } from '@mappedin/react-sdk/geojson/src/entities/geometry-group';
     import type { Text3DComponent } from '@mappedin/react-sdk/geojson/src/components/text3d';
     import type { ModelStyleComponnet, Text3DStyleComponent } from '@mappedin/react-sdk/geojson/src/components/styles';
+    import type { OutlineComponent } from '@mappedin/react-sdk/geojson/src/components/outline';
     export enum Geometry3DComponents {
             Mesh = 0,
             Style = 1,
-            Interaction = 2
+            Interaction = 2,
+            Outline = 3
     }
     type Geometry3DObjectTypes = 'geometry' | 'path' | 'model' | 'custom-geometry' | 'image' | 'text3d';
     export class Geometry3DObject3D extends Object3D {
@@ -11877,16 +13115,17 @@ declare module '@mappedin/react-sdk/geojson/src/entities/geometry3d' {
     }
     export type MeshComponentTypes = MeshComponent | PathComponent | ModelComponent | CustomGeometryComponent | Text3DComponent | ImageComponent;
     type MappedComponentType<M> = M extends MeshComponent ? 'geometry' : M extends PathComponent ? 'path' : M extends ModelComponent ? 'model' : M extends CustomGeometryComponent ? 'custom-geometry' : M extends ImageComponent ? 'image' : M extends Text3DComponent ? 'text3d' : never;
-    export class Geometry3D<M extends MeshComponentTypes = MeshComponent, S extends StyleComponent | Text3DStyleComponent | ModelStyleComponnet = StyleComponent, I extends InteractionComponent = InteractionComponent, T extends MappedComponentType<M> = MappedComponentType<M>> {
+    export class Geometry3D<M extends MeshComponentTypes = MeshComponent, S extends StyleComponent | Text3DStyleComponent | ModelStyleComponnet = StyleComponent, I extends InteractionComponent = InteractionComponent, T extends MappedComponentType<M> = MappedComponentType<M>, O extends OutlineComponent | undefined = OutlineComponent | undefined> {
             id: string | number;
-            components: [M, S, I?];
+            components: [M, S, I?, O?];
             get object3d(): M["mesh"];
             get parentObject3D(): GroupContainerObject3D | GeometryGroupObject3D | null;
             get type(): T;
             entities2D: Map<string | number, Geometry2D>;
             constructor(meshComponent: M, styleComponent: S);
-            addEntity(entity: Geometry2D): void;
-            removeEntity(entity: Geometry2D): void;
+            /** Attaching a 2D entity to the 3D entity so it will follow the style changes */
+            attach(entity: Geometry2D): void;
+            detach(entity: Geometry2D): void;
             removeAllEntities(): void;
     }
     export type TextGeometry3D = Geometry3D<Text3DComponent, Text3DStyleComponent, InteractionComponent, 'text3d'>;
@@ -11989,27 +13228,29 @@ declare module '@mappedin/react-sdk/geojson/src/entities/geometry2d' {
     import type { InteractionComponent } from '@mappedin/react-sdk/geojson/src/components/interaction';
     import { type GeometryGroupObject3D } from '@mappedin/react-sdk/geojson/src/entities/geometry-group';
     export enum Geometry2DComponents {
-        UI = 0,
-        Interaction = 1
+            UI = 0,
+            Interaction = 1
     }
     export class Geometry2DObject3D extends Object3D {
     }
     export class Geometry2D {
-        id: string | number;
-        get type(): 'label' | 'marker';
-        get parentObject3D(): GroupContainerObject3D | GeometryGroupObject3D | null;
-        verticalOffset: number;
-        /**
-          * When the position of the entity changes, this should be set to true, so that systems like pan bounds can update
-          */
-        positionDirty: boolean;
-        occluderId?: number;
-        object3d: Geometry2DObject3D;
-        components: [MarkerComponent | LabelComponent, InteractionComponent?];
-        disposed: boolean;
-        constructor(ui: MarkerComponent | LabelComponent, position: Vector3, verticalOffset?: number);
-        get position(): Vector3;
-        setAltitude(z: number): void;
+            id: string | number;
+            get type(): 'label' | 'marker';
+            get parentObject3D(): GroupContainerObject3D | GeometryGroupObject3D | null;
+            /** The geometry3D that this 2D entity is attached to */
+            get attachedTo(): string | number | undefined;
+            verticalOffset: number;
+            /**
+                * When the position of the entity changes, this should be set to true, so that systems like pan bounds can update
+                */
+            positionDirty: boolean;
+            occluderId?: number;
+            object3d: Geometry2DObject3D;
+            components: [MarkerComponent | LabelComponent, InteractionComponent?];
+            disposed: boolean;
+            constructor(ui: MarkerComponent | LabelComponent, position: Vector3, verticalOffset?: number);
+            get position(): Vector3;
+            setAltitude(z: number): void;
     }
 }
 
@@ -12034,13 +13275,17 @@ declare module '@mappedin/react-sdk/geojson/src/services/text3d/text3d' {
     import { BatchedText, Text } from 'troika-three-text';
     import type { RendererCore } from '@mappedin/react-sdk/geojson/src';
     import type { Text3DComponent } from '@mappedin/react-sdk/geojson/src/components/text3d';
+    import { syncText } from '@mappedin/react-sdk/geojson/src/services/text3d/utils';
+    export function configureTroikaTextBuilder({ useWorker }: {
+            useWorker: boolean;
+    }): void;
     export function createTroikaTextPoint(entityId: string | number, text3DComponent: Text3DComponent, styleComponent: Text3DStyleComponent, convertTo3DMapPosition: RendererCore['convertTo3DMapPosition']): Promise<{
             text: Text;
     }>;
     export function createTroikaTextArea(entityId: string | number, text3DComponent: Text3DComponent, styleComponent: Text3DStyleComponent, convertTo3DMapPosition: RendererCore['convertTo3DMapPosition']): Promise<{
             text: Text;
     } | undefined>;
-    export { BatchedText, Text };
+    export { BatchedText, Text, syncText };
     /**
         * Promise caches the base64 font string. Then shared across all needed
         */
@@ -12058,11 +13303,21 @@ declare module '@mappedin/react-sdk/geojson/src/services/text3d/text3d' {
     export type ModuleType = {
             createTroikaTextPoint: typeof createTroikaTextPoint;
             createTroikaTextArea: typeof createTroikaTextArea;
+            configureTroikaTextBuilder: typeof configureTroikaTextBuilder;
             preloadFont: typeof preloadFont;
+            syncText: typeof syncText;
             BatchedText: typeof BatchedText;
     };
 }
 
+declare module '@mappedin/react-sdk/geojson/src/components/focusable' {
+    import type { Mesh } from 'three';
+    export class FocusableComponent {
+        focusMesh?: Mesh;
+        dirty: boolean;
+    }
+}
+
 declare module '@mappedin/react-sdk/geojson/src/components/geometry-group-style' {
     import { type Shading } from '@mappedin/react-sdk/geojson/src/types';
     type GeometryGroupStyle = {
@@ -12446,6 +13701,7 @@ declare module '@mappedin/react-sdk/geojson/src/systems/mesh-creation-and-optimi
     import { PubSub } from '@packages/internal/common';
     import type { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
     import type { ModelStyle } from '@mappedin/react-sdk/geojson/src/components/styles';
+    import { OutlineComponent } from '@mappedin/react-sdk/geojson/src/components/outline';
     export class MeshCreationAndOptimizationSystem extends PubSub<{
         'model-loaded': void;
         'geometry-2d-added': void;
@@ -12455,7 +13711,7 @@ declare module '@mappedin/react-sdk/geojson/src/systems/mesh-creation-and-optimi
         loader?: GLTFLoader;
         constructor(state: RendererState, convertTo3DMapPosition: any);
         getGLTFLoader(): Promise<GLTFLoader>;
-        createEntityFromFeature(id: string | number, feature: Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties>, style?: LineStyle | PaintStyle): Geometry3D<MeshComponent, StyleComponent, import("../../components/interaction").InteractionComponent, "geometry">;
+        createEntityFromFeature(id: string | number, feature: Feature<Polygon | LineString | MultiPolygon, MeshComponentProperties>, style?: LineStyle | PaintStyle): Geometry3D<MeshComponent, StyleComponent, import("../../components/interaction").InteractionComponent, "geometry", OutlineComponent | undefined>;
         createModelFromFeature(id: string | number, feature: Feature<Point, ModelProperties>, style?: Partial<ModelStyle>): ModelGeometry3D;
         populateEntityMesh(entity: Geometry3D, geometry: BufferGeometry): void;
         populateModelGroup(entities: Set<string | number>, url: string, tree: GeometryGroupObject3D): Promise<Geometry3DObject3D>;
@@ -12813,7 +14069,7 @@ declare module '@mappedin/react-sdk/geojson/src/systems/dom-resize/system' {
         observers: Map<string | number, ResizeObserver>;
         constructor(state: RendererState, domTree: Entity2DHTMLDivElementContainer);
         setupObserver(): void;
-        updateDimensions: (mutations: any) => void;
+        updateDimensions: (mutations: ResizeObserverEntry[]) => void;
         update(): void;
         destroy(): void;
     }
@@ -12855,9 +14111,9 @@ declare module '@mappedin/react-sdk/geojson/src/systems/outline-interpolation/sy
     export class OutlineInterpolationSystem {
             #private;
             /**
-                * Set to true when we need to update the outline color of all entities, regardless of zoom level.
+                * Set to true when we need to update the outline opacity of all entities, regardless of zoom level.
                 */
-            dirty: boolean;
+            outlineOpacitiesDirty: boolean;
             get geometries3DDirty(): boolean;
             set geometries3DDirty(value: boolean);
             constructor(rendererState: RendererState);
@@ -12866,7 +14122,8 @@ declare module '@mappedin/react-sdk/geojson/src/systems/outline-interpolation/sy
                 * @param zoomLevel - The current zoom level.
                 * @param isCameraZoomDirty - Whether the zoom level has changed since the last update. If this is true, the system will update if zoomLevel falls between range.
                 */
-            update(zoomLevel: number, isCameraZoomDirty?: boolean): void;
+            update(zoomLevel: number, isCameraZoomDirty?: boolean): null | undefined;
+            destroy(): void;
     }
 }
 
@@ -12910,6 +14167,7 @@ declare module '@mappedin/react-sdk/geojson/src/systems/geometry-in-focus/system
             resize(): void;
             update: (cameraIsMoving?: boolean, cameraStoppedMovingTime?: number) => void;
             updateRaf(): void;
+            raycast(): void;
             showRaycasters(): void;
             hideRaycasters(): void;
             destroy(): void;
@@ -12917,14 +14175,16 @@ declare module '@mappedin/react-sdk/geojson/src/systems/geometry-in-focus/system
 }
 
 declare module '@mappedin/react-sdk/geojson/src/systems/outdoor-layers/system' {
-    import type { Map } from '@packages/internal/outdoor-context-v4';
+    import type { LegacyFilterSpecification, Map } from '@packages/internal/outdoor-context-v4';
     import type { Position } from '@mappedin/react-sdk/geojson/src/renderer';
     import { type BBox } from 'geojson';
     export class OutdoorLayers {
+        #private;
         dirty: boolean;
         hideLayersUnderPoint(point: Position, layers: string[]): void;
         hideLayersIntersectingPolygons(bbox: BBox, polygons: GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon, any>[], layers: string[]): void;
         constructor(map?: Map);
+        expr: LegacyFilterSpecification[];
         destroy(): void;
     }
 }
@@ -13008,7 +14268,6 @@ declare module '@mappedin/react-sdk/geojson/src/components/styles/style' {
         topColor?: string;
         texture?: string;
         topTexture?: string;
-        outline: boolean;
         showImage: boolean;
         flipImageToFaceCamera: boolean;
         url?: string;
@@ -13032,7 +14291,6 @@ declare module '@mappedin/react-sdk/geojson/src/components/styles/style' {
         altitude: number;
         join: LineStyle['join'];
         cap: LineStyle['cap'];
-        outline: boolean;
         showImage: boolean;
         flipImageToFaceCamera: boolean;
         url?: string;
@@ -13157,6 +14415,35 @@ declare module '@mappedin/react-sdk/geojson/src/entities' {
     export type { PathMesh, PatMeshContainer, PathMaterial, Geometry3DTypes, ImageGeometry3D, TextGeometry3D, ModelGeometry3D, CustomGeometry3D, MeshGeometry3D, } from '@mappedin/react-sdk/geojson/src/entities/geometry3d';
 }
 
+declare module '@mappedin/react-sdk/geojson/src/systems/collisions/collider-processor' {
+    import { Rectangle } from '@packages/internal/quad-tree';
+    export type TSerializedCollider = {
+        rank: number;
+        enabledAndVisible: boolean;
+        x: number;
+        y: number;
+        bboxes: {
+            index: number;
+            boundingBox: [number, number, number, number];
+            boundingRect?: Rectangle;
+        }[];
+        shouldCollideWithScreenEdges?: boolean;
+        lockedToStrategyIndex?: number;
+        visible?: boolean;
+    };
+    export type TSerializedColliderResponse = [number, 1 | 0, Rectangle?];
+    export function processColliders(colliders: TSerializedCollider[], totalWidth: any, totalHeight: any, watermarkWidth: any, watermarkHeight: any, watermarkPosition: any, msgId?: string): {
+        msgId: string;
+        colliders: TSerializedColliderResponse[];
+        debug: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        }[];
+    };
+}
+
 declare module '@mappedin/react-sdk/geojson/src/systems/exporter/exporter' {
     import type { RendererState } from '@mappedin/react-sdk/geojson/src/renderer';
     export type GLTFExportOptions = {
@@ -13429,12 +14716,11 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-object' {
     import type { MapDataInternal } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     class Layer {
         containerId: string;
-        labelIds: Set<string>;
         layers: Map<string, string>;
         renderer: RendererCore;
         constructor(renderer: RendererCore, containerId: string, layers?: Map<any, any>);
-        show(): void;
-        hide(): void;
+        get visible(): boolean;
+        setVisible(visible: boolean): void;
     }
     export class FloorObject implements MVFFloor {
         #private;
@@ -13462,18 +14748,18 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-object' {
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/utils' {
-    import { Coordinate, type Floor, type MapObject, type Space, type Facade } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
+    import { Coordinate, MapObject, Space, type Floor, type Facade } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
     import type { EntranceCollection, LineString, Polygon, Point, SpaceProperties, ObstructionProperties, StyleCollection, PolygonStyle, LineStringStyle, Feature, ObstructionCollection, PointStyle } from '@mappedin/mvf';
     import type { PolygonFeatureProperties } from '@packages/internal/mvf-utils';
     import type { BBox, FeatureCollection, MultiLineString } from 'geojson';
-    import type { LabelState, MarkerState, GeometryState, CollisionRankingTier, LineStyle, PaintStyle, Position, GroupContainerState } from '@mappedin/core-sdk';
-    import { type TGeometryState, type TLabelState, type TDirectionInstructionAction, type TShow3DMapOptions, type Label, type Marker, type Model } from '@mappedin/react-sdk/mappedin-js/src';
-    import type { TDoorsState, TFloorState, TMarkerState, TWallsState } from '@mappedin/react-sdk/mappedin-js/src/types';
+    import type { LabelState, MarkerState, GeometryState, CollisionRankingTier, LineStyle, PaintStyle, Position, EntityId, PathState } from '@mappedin/core-sdk';
+    import { type TGeometryState, type TLabelState, type TDirectionInstructionAction, type TShow3DMapOptions, type Label, type Marker, type Model, MapData } from '@mappedin/react-sdk/mappedin-js/src';
+    import type { IAnchorable, TDoorsState, TMarkerState, TWallsState } from '@mappedin/react-sdk/mappedin-js/src/types';
     import type { Image, Path, Shape, Text3D } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects';
     import type { GeoJsonApi } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/api';
     import type { Tween } from '@tweenjs/tween.js';
     import type { PathSegment } from '@mappedin/react-sdk/mappedin-js/src/map-view-objects/path';
-    import { FloorObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-object';
+    import type { FloorObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-object';
     export function convertCoordinateToPosition(coord: Coordinate): Position;
     export function convertPositionToCoordinate(coord: Position): Coordinate;
     export const cutEntrancesFromLineStrings: (lineStrings: ObstructionCollection["features"], entranceCollection: EntranceCollection["features"]) => {
@@ -13485,7 +14771,6 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/utils' {
     export function translateDoorsStateToGeojsonCore(state: Partial<TDoorsState>, currentState: Partial<GeometryState>): Partial<GeometryState>;
     export function translateWallsStateToGeojsonCore(state: Partial<TWallsState>, currentState: Partial<GeometryState>): Partial<GeometryState>;
     export function translateSpaceStateToGeojsonCore(state: Partial<TGeometryState>, currentState: Partial<GeometryState>): Partial<GeometryState>;
-    export function translateFloorGeometryStateToGeojsonCore(state: TFloorState['geometry']): Partial<GroupContainerState>;
     export function differenceBetweenAngles(a: number, b: number): number;
     export function getRelativeBearing(relativeBearingAngle: number, threshold: number): TDirectionInstructionAction['bearing'];
     export function convertCollisionRankingTeirToNumber(tier: CollisionRankingTier): number;
@@ -13507,6 +14792,11 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/utils' {
     export function expandBbox(bbox: BBox, bboxToExpand: BBox): number[];
     export function unique<T>(array: T[]): T[];
     export function getTargetFloorObject(coordinate: Coordinate, floorsById: Map<string, FloorObject>, defaultFloor: FloorObject): FloorObject;
+    /** Gets the ID of a geometry that 2D entities can attach to */
+    export function getAttachableGeometryId(target: IAnchorable): string | undefined;
+    export function determineFloorVisibleBasedOnPath(path: EntityId<PathState> & {
+        coordinates: Coordinate[];
+    }, mapData: MapData, api: GeoJsonApi): boolean;
 }
 
 declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-stack-object' {
@@ -13534,105 +14824,54 @@ declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/floor-stack-obje
     }
 }
 
-declare module '@mappedin/react-sdk/mappedin-js/src/api-geojson/dynamic-focus/dynamic-focus' {
-    import { type RendererCore } from '@mappedin/core-sdk';
-    import { PubSub } from '@packages/internal/common';
-    import type { Floor, FloorStack } from '@mappedin/react-sdk/mappedin-js/src/map-data-objects';
-    import type { GeoJsonApi } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/api';
-    import type { GeojsonApiMapObject } from '@mappedin/react-sdk/mappedin-js/src/api-geojson/map-object';
-    /**
-        * @experimental
-        * @internal
-        */
-    export type TDynamicFocusEvents = {
-            'focus-change': {
-                    facades: string[];
-                    spaces: string[];
-            };
-    };
-    /**
-        * @experimental
-        * @internal
-        */
-    export type TDynamicFocusOptions = {
-            /**
-                * The minimum zoom level at which Dynamic Focus will detect a Facade and reveal the interior spaces.
-                * @default 17
-                */
-            minZoomLevel?: number;
+declare module '@mappedin/react-sdk/geojson/src/components/outline' {
+    import type { BufferAttribute, BufferGeometry } from 'three';
+    type Outline = {
+        color: string;
+        dirty: boolean;
+        visible: boolean;
+        edgeColors?: BufferAttribute;
+        ranges?: {
+            start: number;
+            count: number;
+        };
+        geometry?: BufferGeometry;
+        currentOpacity: number;
+        currentColor: [number, number, number];
+        topFaceVerticesIndices?: number[];
     };
-    /**
-        * @experimental
-        * @internal
-        */
-    export class DynamicFocus extends PubSub<TDynamicFocusEvents> {
-            #private;
-            /** @internal */
-            constructor(core: RendererCore, geoJSONApi: GeoJsonApi, { currentMapGetter }: {
-                    currentMapGetter: CurrentMapGetter;
-            });
-            get focusedFacades(): import("../../map-data-objects").Facade[];
-            /**
-                * @experimental
-                * Enables Dynamic Focus and allows the camera to automatically set the floor stack when a facade is hovered.
-                */
-            enable(options?: TDynamicFocusOptions): void;
-            /**
-                * @experimental
-                * Disables Dynamic Focus and prevents the camera from automatically setting the floor stack when a facade is hovered.
-                */
-            disable(): void;
-            /**
-                * @experimental
-                * Returns the enabled state of Dynamic Focus.
-                */
-            get enabled(): boolean;
-            /**
-                * @experimental
-                * Sets the default floor for a floor stack. This is the floor that will be shown when the floor stack is in focus.
-                * See {@link resetDefaultFloorForStack} to reset the default floor.
-                * @param floorStack - The floor stack to set the default floor for.
-                * @param floor - The floor to set as the default floor.
-                */
-            setDefaultFloorForStack(floorStack: FloorStack, floor: Floor): void;
-            /**
-                * @experimental
-                * Resets the default floor for a floor stack to it's initial value.
-                * @param floorStack - The floor stack to reset the default floor for.
-                */
-            resetDefaultFloorForStack(floorStack: FloorStack): void;
+    export class OutlineComponent implements Outline {
+        color: string;
+        dirty: boolean;
+        visible: boolean;
+        edgeColors?: BufferAttribute;
+        geometry?: BufferGeometry;
+        ranges?: {
+            start: number;
+            count: number;
+        };
+        topFaceVerticesIndices?: number[];
+        get currentOpacity(): number;
+        get currentColor(): [number, number, number];
+        constructor(color: string);
     }
-    type CurrentMapGetter = () => GeojsonApiMapObject | undefined;
     export {};
 }
 
-declare module '@mappedin/react-sdk/geojson/src/systems/collisions/collider-processor' {
-    import { Rectangle } from '@packages/internal/quad-tree';
-    export type TSerializedCollider = {
-        rank: number;
-        enabledAndVisible: boolean;
-        x: number;
-        y: number;
-        bboxes: {
-            index: number;
-            boundingBox: [number, number, number, number];
-            boundingRect?: Rectangle;
-        }[];
-        shouldCollideWithScreenEdges?: boolean;
-        lockedToStrategyIndex?: number;
-        visible?: boolean;
-    };
-    export type TSerializedColliderResponse = [number, 1 | 0, Rectangle?];
-    export function processColliders(colliders: TSerializedCollider[], totalWidth: any, totalHeight: any, watermarkWidth: any, watermarkHeight: any, watermarkPosition: any, msgId?: string): {
-        msgId: string;
-        colliders: TSerializedColliderResponse[];
-        debug: {
-            x: number;
-            y: number;
-            w: number;
-            h: number;
-        }[];
-    };
+declare module '@mappedin/react-sdk/geojson/src/services/text3d/utils' {
+    import type { Text } from 'troika-three-text';
+    /**
+        * Load font file and kick off the font processing.
+        * Promise gets resolved when preloadFont finishes.
+        */
+    export function preloadFont(fontUrl?: string): Promise<string>;
+    /**
+        * Fit text to area with a given max width and height, scaling the font size down if necessary.
+        */
+    export function fitTextToArea(text: Text, maxWidth: number, maxHeight: number, scaleStep: number): Promise<{
+            size: [width: number, height: number];
+    }>;
+    export function syncText(text: Text): Promise<void>;
 }
 
 declare module '@mappedin/react-sdk/geojson/src/systems/interactions/system' {