@mappedin/react-native-sdk 5.23.0 → 5.24.0

package/dist/index.d.ts

@@ -666,7 +666,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/MapView.types'
             pulseColor?: string;
             /**
                 * Number of iterations to pulse to indicate direction
-                * @defaultValue Infinity
+                * @defaultValue 1
                 */
             pulseIterations?: number;
             /**
@@ -794,7 +794,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/MapView.types'
             /**
                 * What color to highlight departure and destination polygons
                 * Pass false to disable
-                * @default '#ff834c'
+                * @default '#7babc8'
                 */
             polygonHighlightColor?: string | false;
             /**
@@ -893,6 +893,10 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/MapView.types'
                 * @default false
                 */
             interactive?: boolean;
+            /**
+                * Optional layer to attach the {@link Marker} to.
+                */
+            layer?: string;
     };
     /**
         * Configurations for an animation
@@ -932,6 +936,10 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/MapView.types'
                 * The rank of the object used when comparing colliders to determine which should be shown.
                 */
             collisionRank?: COLLISION_RANKING_TIERS;
+            /**
+                * Optional layer to attach the Tooltip to.
+                */
+            layer?: string;
     };
     export type TCreateTooltipOptions = TCreateTooltipCommonOptions & {
             /**
@@ -1073,26 +1081,32 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/MapView.types'
                 */
             dynamicFocus?: {
                     /**
-                        * The Dynamic Focus Map to always be visible
+                        * The Dynamic Focus Map to always be visible.
                         */
                     baseMap?: MappedinMap;
                     /**
-                        * Mercator Zoom level where the indoors are fully visible
+                        * Mercator Zoom level where the indoors are fully visible.
                         */
                     indoorsFullyVisibleZoomLevel?: number;
                     /**
-                        * Mercator Zoom level when the outdoors geometry is fully visible
+                        * Mercator Zoom level when the outdoors geometry is fully visible.
                         */
                     buildingFullyVisibleZoomLevel?: number;
                     /**
-                        * Level at which the map is "set", and colliders become visible
+                        * Level at which the map is "set", and colliders become visible.
                         */
                     setMapAtZoomLevel?: number;
                     /**
-                        * Whether we should preload the default maps of each building
-                        * This will incur a cost up-front, but make transitions smoother
+                        * Whether we should preload the default maps of each building.
+                        * This will incur a cost up-front, but make transitions smoother.
+                        * @default false
                         */
                     preloadDefaultMaps?: boolean;
+                    /**
+                        * An array of base map layer names which should remain active when the focus has changed to a building map.
+                        * This could include outdoor {@link FloatingLabel}s or {@link Marker}s that are attached to the base map.
+                        */
+                    keepLayersActiveOnBaseMap?: string[];
             };
             /**
                 * @experimental
@@ -1365,6 +1379,11 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/MapView.types'
                 * @default false
                 */
             interactive?: boolean;
+            /**
+                * Optional layer to attach the FloatingLabel to.
+                * If not provided, this will be empty or the layer of the {@link MappedinPolygon} that the label is attached to.
+                */
+            layer?: string;
     };
     export type TLabelAllLocationCommonOptions = {
             /**
@@ -1588,8 +1607,14 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue' {
         */
     export function isomorphicFetch(): Window['fetch'];
     /**
-        * @internal
-        * Overwrite the internal `fetch` function with your own. Typically for use in Node.js and Jest
+        * Overwrite the internal `fetch` function with your own. Typically for use in Node.js and Jest.
+        *
+        * @example
+        * ```js
+        * const { getVenue } = require("@mappedin/mappedin-js/lib/node/index");
+        * setFetchFn(require("node-fetch-commonjs"));
+        * ```
+        *
         */
     export function setFetchFn(fetchFn: any): void;
     /** Classes */
@@ -1690,6 +1715,10 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue' {
     };
     export type TGetVenueMVFOptions = TGetVenueBundleOptions & {
             onMVFParsed?: (mvf: ParsedMVF) => void;
+            /**
+                * Override initial MVF data
+                */
+            override?: Partial<Pick<ParsedMVF, 'styles.json'>>;
     };
     /**
         * @deprecated
@@ -2667,6 +2696,7 @@ declare module '@mappedin/react-native-sdk/wrappers/common/payloads' {
                                 */
                             searchOptions?: TMappedinOfflineSearchOptions;
                     };
+                    context: string;
             };
             [EVENT.SHOW_VENUE]: {
                     venueData: string;
@@ -3476,6 +3506,7 @@ declare module '@mappedin/react-native-sdk/wrappers/common/controller' {
                                             prepareSearch?: boolean;
                                             searchOptions?: Partial<import("../react-native-sdk/src").TMappedinOfflineSearchAllOptions>;
                                     };
+                                    context: string;
                             };
                     };
                     SHOW_VENUE: {
@@ -4096,6 +4127,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
                 */
             appearance?: TFloatingLabelAppearance;
             createDespiteImage?: boolean;
+            layer?: string;
     };
     enum PINVISIBILITY {
             OPAQUE = 1,
@@ -4149,6 +4181,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
 declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappedin.BlueDot/Mappedin.BlueDot.core' {
     import { IStateMachine } from '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappedin.BlueDot/Mappedin.BlueDot.StateMachine';
     import { E_BLUEDOT_MARKER_STATE, E_BLUEDOT_STATE, E_BLUEDOT_STATE_REASON } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.enums';
+    import PositionSmoothing from '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappedin.BlueDot/position-smoothing';
     import { PubSub, IPubSub } from '@mappedin/react-native-sdk/core/packages/renderer/internal/pub-sub';
     import { MappedinMap, MappedinNode } from '@mappedin/react-native-sdk/core/packages/get-venue';
     import { TGeolocationObject } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.types';
@@ -4213,16 +4246,17 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
                 */
             useRotationMode?: boolean;
     };
-    type TUserData = {
+    export type TUserData = {
             state: E_BLUEDOT_STATE;
             position: TGeolocationObject | null;
             map: MappedinMap | null;
             bearing: any;
             nearestNode: any;
+            forceBlueDot: boolean;
     };
     export interface IBlueDotCore extends IPubSub {
             positionUpdater: IPositionUpdater | null;
-            positionSmoothing: any;
+            positionSmoothing: PositionSmoothing;
             locationUncertainTimeoutPeriod: number;
             fallbackToGPSTimeoutPeriod: number;
             enableBlueDot: (options?: TEnableBlueDotOptions) => void;
@@ -4310,7 +4344,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
 }
 
 declare module '@mappedin/react-native-sdk/core/packages/renderer/private/controllers/PathsController' {
-    import { MappedinNode } from '@mappedin/react-native-sdk/core/packages/get-venue';
+    import { MappedinNode, MappedinCoordinate } from '@mappedin/react-native-sdk/core/packages/get-venue';
     import type { ICore, TPathOptions } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     import { ANIMATION_TWEENS } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     /**
@@ -4330,7 +4364,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
         */
     export type TInternalPathSegment = {
             id: string;
-            nodes: MappedinNode[];
+            nodes: (MappedinNode | MappedinCoordinate)[];
             mapId?: string;
             isConnectionPathSegment?: boolean;
             reset: () => void;
@@ -4355,6 +4389,10 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
                 * A {@link MappedinNode}[] representing the nodes in the path
                 */
             get nodes(): MappedinNode[];
+            /**
+                * A {@link MappedinCoordinate}[] representing the coordinates in the path
+                */
+            get coordinates(): MappedinCoordinate[];
     }
     /**
         * @hidden
@@ -4365,9 +4403,10 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
     export class InternalPath {
             id: string;
             nodes: MappedinNode[];
+            coordinates: MappedinCoordinate[];
             pathSegments: TInternalPathSegment[];
             options: TPathOptionsInternal;
-            constructor(nodes: MappedinNode[], pathSegments: TInternalPathSegment[], options: TPathOptionsInternal);
+            constructor(path: (MappedinNode | MappedinCoordinate)[], pathSegments: TInternalPathSegment[], options: TPathOptionsInternal);
     }
     /**
         * @hidden
@@ -4423,7 +4462,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
                 *
                 * @returns {Array} Array of Tween segments representing paths drawn on screen
                 */
-            drawPath(path: MappedinNode[], options?: TPathOptionsInternal): Path;
+            drawPath(path: (MappedinNode | MappedinCoordinate)[], options?: TPathOptionsInternal): Path;
             /**
                 * Redraw an existing path with optional new options. This avoids changing its ID or reference.
                 */
@@ -4478,6 +4517,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
                     [type: string]: boolean;
             };
             interactive?: boolean;
+            layer?: string;
     };
     type TTooltipStyle = {
             top?: string;
@@ -5166,7 +5206,7 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.Cust
                 * This method should be called whenever the user's position changes. This information will be sent when a track call is made.
                 * @param position {AnalyticsUserPosition} The user's current position.
                 */
-            updateAnalyticsUserPosition(position: AnalyticsUserPosition | undefined): void;
+            updateAnalyticsUserPosition(position: Omit<AnalyticsUserPosition, 'bluedotTimestamp'> | undefined): void;
             /**
                 * Whenever a location is selected, you should fire this event. What "selected" means can vary by venue,
                 * but a good rule of thumb is that you fire the event whenever you would show the location's details.
@@ -5955,6 +5995,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
         text: string;
         createDespiteImage: boolean | undefined;
         coordinate?: MappedinCoordinate;
+        layer?: string;
     };
     class FloatingLabelsController {
         #private;
@@ -6189,7 +6230,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal' {
     import { STATE } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.enums';
     import { TMapClickEvent } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.types';
     import { MappedinMap } from '@mappedin/react-native-sdk/core/packages/get-venue';
-    export { MappedinMap, Mappedin, MappedinCoordinate, MappedinPolygon, MappedinNode } from '@mappedin/react-native-sdk/core/packages/get-venue';
+    export { MappedinMap, Mappedin, MappedinCoordinate, MappedinPolygon, MappedinNode, MappedinLocation, MappedinVenue, } from '@mappedin/react-native-sdk/core/packages/get-venue';
     export type { TEnableBlueDotOptions, TFloatingLabelAppearance, TGeolocationObject, TPathOptions, TConnectionProps, TConnectionTemplateFn, TMarkerTemplateProps, TMarkerTemplateFn, TJourneyOptions, TPadding, TCreateMarkerOptions, TAnimationOptions, TCreateTooltipInternalOptions, TCreateTooltipCommonOptions, TCreateTooltipOptions, TCreateTextTooltipOptions, TCreateCustomInnerHTMLTooltipOptions, TCreateCustomTooltipOptions, TCreateThreeDMarkerOptions, TGetPolygonsAtCoordinateOptions, TMapViewOptions, TMapViewOptionsLegacy, TFlatLabelOptions, TFlatLabelAppearance, TFloatingLabelPolygonOptions, TAddFlatLabelOptions, TAddFloatingLabelOptions, TLabelAllLocationCommonOptions, TLabelAllLocationFloatingLabelOptions, TLabelAllLocationFlatLabelOptions, TFloatingLabelAllLocationsOptions, TFlatLabelAllLocationsOptions, changeListenerFn, TMapClickEvent, E_SDK_EVENT_PAYLOAD, E_BLUEDOT_EVENT_PAYLOAD, CAMERA_EVENT_PAYLOAD, } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.types';
     export { labelThemes } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.types';
     export { GEOLOCATION_STATUS, COLLISION_RANKING_TIERS, E_BLUEDOT_STATE_REASON, E_BLUEDOT_STATE, E_BLUEDOT_MARKER_STATE, STATE, MARKER_ANCHOR, E_SDK_EVENT, E_BLUEDOT_EVENT, E_CAMERA_EVENT, E_CAMERA_DIRECTION, SAFE_AREA_INSET_TYPE, CAMERA_EASING_MODE, MAP_RENDER_MODE, ANIMATION_TWEENS, STACKED_MAPS_STATE, } from '@mappedin/react-native-sdk/core/packages/renderer/MapView.enums';
@@ -6591,8 +6632,8 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
         accessible: boolean;
         activeDirections: MappedinDirections;
         get isMultiFloor(): boolean;
-        get mapsInJourney(): any[];
-        get buildingsInJourney(): any;
+        get mapsInJourney(): import("../../internal").MappedinMap[];
+        get buildingsInJourney(): {};
         get mapIdsInvolvedInJourney(): string[];
         constructor(directions: MappedinDirections | MappedinDirections[], options: TJourneyOptions, core: ICore);
         setStep: (step: any) => void;
@@ -6604,7 +6645,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/contro
 }
 
 declare module '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.MVF.types' {
-    import { MapId } from '@mappedin/mvf';
+    import { MapId, ObstructionCollection, EntranceCollection, SpaceCollection, Style } from '@mappedin/mvf';
     import { FeatureCollection, MultiPolygon, Point, Polygon } from 'geojson';
     import { TImage, TMap, TNode, TOpeningHours, TPhone, TSiblingGroup, TSocial } from '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.API.types';
     export type WithIDs<T> = Map<string, T>;
@@ -6617,6 +6658,13 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.MVF.
             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 MVFv1PolygonLikeProperties = {
             id: string;
             altitude?: number;
@@ -7534,7 +7582,7 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue/MappedinMapGr
 declare module '@mappedin/react-native-sdk/core/packages/get-venue/utils' {
     import type { TGetVenueOptions, TGetVenueOptionsInternal } from '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.types';
     import type { MappedinMap } from '@mappedin/react-native-sdk/core/packages/get-venue/internal';
-    import { MappedinNavigatable, MappedinNode, MappedinCoordinate } from '@mappedin/react-native-sdk/core/packages/get-venue/internal';
+    import { Mappedin, MappedinNavigatable, MappedinNode, MappedinPolygon, MappedinLocation, MappedinCoordinate } from '@mappedin/react-native-sdk/core/packages/get-venue/internal';
     export function isGatewayKey(key: string): boolean;
     export function stringifyQuery(query: any, gateway?: boolean): string;
     export function buildUrl(options: TGetVenueOptionsInternal & TGetVenueOptions, pathname: string, query: any, supplementary?: boolean): string;
@@ -7589,6 +7637,21 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue/utils' {
         * @returns the normalized value
         */
     export function normalizeCategoryRank(sortOrder: number, min: number, max: number, polygonRank?: number): number;
+    export function getDeviceID(): string;
+    export function getSessionID(): string;
+    /**
+        * Finds the main Location associated with a Polygon. This means a Location
+        * attached to the Polygon that has no parents, or, if there are none of those,
+        * a Location nearest the top of some hierarchy that does have the Polygon attached.
+        *
+        * This means if there are multiple hierarchies of Locations attached to the Polygon,
+        * the one that gets returned is not guaranteed to be what you want.
+        *
+        * @method getPrimaryLocationForPolygon
+        * @param polygon {MappedinPolygon} The Polygon you want the primary Location of.
+        * @return {MappedinLocation}
+        */
+    export const getPrimaryLocationForPolygon: (polygon: MappedinPolygon | string | undefined, venue: Mappedin) => MappedinLocation | null;
 }
 
 declare module '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.cache' {
@@ -8348,7 +8411,7 @@ declare module '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.Task
 declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-manager/MapView.SceneManager' {
     import { MappedinMap } from '@mappedin/react-native-sdk/core/packages/get-venue';
     import type { ICore, TCameraAnimationOptions, TFocusOnCameraOptions, TCameraTargets } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
-    import { MapViewScene } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
+    import { MapObject, MapViewScene } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     export type TSceneTransitionOptions = {
             /**
                 * Map to set as active during the transition. This will decide where the camera will be positioned, as well as which
@@ -8389,7 +8452,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
 }
 
 declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-manager/MapView.DynamicFocusSceneManager' {
-    import { MappedinMap } from '@mappedin/react-native-sdk/core/packages/get-venue';
+    import { MappedinMap, MappedinMapGroup } from '@mappedin/react-native-sdk/core/packages/get-venue';
     import type { ICore } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     import { MapViewScene, DynamicFocusScene } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     class DynamicFocusSceneManager {
@@ -8401,9 +8464,11 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
         get currentScene(): {
             resize: () => void;
             currentMap: MappedinMap;
-            mapObjects: Map<string, MapObject>;
+            mapObjects: Map<string, import("../../internal/Mappedin.MapObject").default>;
         };
         get currentMap(): MappedinMap;
+        setDefaultMapForMapGroup(mapGroup: MappedinMapGroup, map: MappedinMap): void;
+        resetDefaultMapForMapGroup(mapGroup: MappedinMapGroup): void;
         determineTargetMap(): void;
         update(): void;
         transitionTo(scene?: MapViewScene): Promise<void>;
@@ -8411,6 +8476,294 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
     export default DynamicFocusSceneManager;
 }
 
+declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappedin.MapObject' {
+    import { Group, Box3, Mesh, MeshLambertMaterial, Object3D, Vector3 } from 'three';
+    import { FrameTaskGroup } from '@mappedin/react-native-sdk/core/packages/get-venue/Mappedin.TaskScheduler';
+    import { Element, FlippableImage, MappedinMap, TaskScheduler, FlatLabel, SmartTooltip, ICore, FloatingLabel } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
+    import { PubSub } from '@mappedin/react-native-sdk/core/packages/renderer/internal/pub-sub';
+    import { TCreateThreeDMarkerOptions } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
+    /**
+        * Some preset priorities for tasks.
+        */
+    export const TASK_PRIORITY: {
+            VISIBLE_MAP_HIGH: number;
+            VISIBLE_MAP_LOW: number;
+            VISIBLE_MAP_MARKER: number;
+            ASYNC_MAP_HIGH: number;
+            ASYNC_MAP_LOW: number;
+            ASYNC_MAP_MARKER: number;
+            MAP_LOADED: number;
+    };
+    export const RENDER_ORDER: {
+            MAP_ELEMENT: number;
+            BUILDING_OUTLINE: number;
+            MAP_HOVER: number;
+            POLYGON_IMAGE: number;
+    };
+    export function convertToShortHandInterpolation(interpolation: any[]): any;
+    export const SCENE_FROM_LIVE_JSON = false;
+    type InterpolationFunctionType = (zoomLevel: number) => any;
+    export class LayerGroup {
+            mergedObjectsGroup: Group;
+            hoverObjectsGroup: Group;
+            objectsByMaterials: Map<MeshLambertMaterial, Element[]>;
+            hoverableMeshChildren: Mesh;
+            _isVisible: boolean;
+            needsUpdate: boolean;
+            userData: any;
+            opacity: number;
+            core: ICore;
+            mapObject: MapObject;
+            name: string;
+            layers: string[];
+            interpolationFn: InterpolationFunctionType | null;
+            opacityInterpolation?: {
+                    zoomLevel: number;
+                    opacity: number;
+            }[] | {
+                    inputZoomLevel: number[];
+                    outputOpacity: number[];
+            };
+            set isVisible(value: boolean);
+            get isVisible(): boolean;
+            constructor(mapObject: MapObject, name: string, layers: string[], visible: boolean);
+            dispose(): void;
+            setOpacity(opacity: any): void;
+    }
+    export interface LoadOptions {
+            async?: boolean;
+            taskScheduler: TaskScheduler;
+            mapRenderStrategy?: string;
+    }
+    interface BoundingBox {
+            min: Vector3;
+            max: Vector3;
+    }
+    interface FadeOptions {
+            onComplete?: () => void;
+            duration: number;
+    }
+    class MapObject extends PubSub {
+            _flippableImagedById: any;
+            _started: boolean;
+            _loaderPromise: Promise<MapObject>;
+            _promiseResolve: (value?: void | PromiseLike<void> | MapObject) => void;
+            _showCount: number;
+            _taskScheduler: TaskScheduler;
+            _highPriorityTasks: FrameTaskGroup;
+            _lowPriorityTasks: FrameTaskGroup;
+            _markerTasks: FrameTaskGroup;
+            _mapLoadedTasks: FrameTaskGroup;
+            _visibilityLatch: boolean | null;
+            _objLoadedComplete: boolean;
+            _hoverableMeshChildren: Mesh[];
+            imageMeshesById: Record<string, Mesh>;
+            visible: boolean;
+            objectsDictionary: Record<string, Mesh>;
+            north: number;
+            mapScale: number | null;
+            object: Object3D;
+            labels: Set<FloatingLabel>;
+            tooltips: Set<SmartTooltip>;
+            markers: Set<unknown>;
+            box: Box3;
+            textObjects: FlatLabel[];
+            labelBatchCreator: any;
+            imagesToFlip: (typeof FlippableImage)[];
+            seenByCamera: boolean;
+            threeJSMarkers: Map<ThreeJSMarkerHandle, {
+                    object: Object3D;
+            }>;
+            core: ICore;
+            mapClass: MappedinMap;
+            polygonMeshesById: Record<string, Mesh>;
+            loadMethod: string;
+            loadAsync: boolean;
+            id: string;
+            mapRenderingStrategy: string;
+            needsUpdate: boolean;
+            layerGroups: Map<string, LayerGroup>;
+            loadedLayerNames: string[];
+            loadedElements: Element[];
+            boundingBox: BoundingBox | undefined;
+            elements: Element[];
+            loadMethodUsed: string;
+            mapLoaded: any;
+            constructor(mapClass: MappedinMap, polygonMeshesById: Record<string, Mesh>, showCount: number, core: ICore, loadOptions: LoadOptions);
+            fade(layerGroupName: string | string[], { direction, onComplete, duration }: {
+                    direction?: string;
+                    onComplete?: () => void;
+                    duration?: number;
+            }): {
+                    start: () => Promise<void>;
+            };
+            /**
+                * Fade a layer group or number of layer groups in
+                * @param {string|string[]} layerGroupNames
+                * @returns
+                */
+            fadeIn(layerGroupNames?: string | string[], options?: FadeOptions): {
+                    start: () => Promise<void>;
+            };
+            /**
+                * Fade a layer group or number of layer groups out
+                * @param {string|string[]} layerGroupNames
+                * @returns
+                */
+            fadeOut(layerGroupNames?: string | string[], options?: FadeOptions): {
+                    start: () => Promise<void>;
+            };
+            renderLayerGroup(include?: string[], exclude?: string[]): void;
+            processLayers(allLayers: string[], include?: string[], exclude?: string[]): string[];
+            processLayerGroup(name?: string, include?: string[], exclude?: string[], visible?: boolean, elements?: Element[], defaultRenderOrder?: number): LayerGroup;
+            get hoverableMeshChildren(): Mesh[];
+            _objLoadedMerged(object: Object3D): Promise<void>;
+            _objLoaded(object: Object3D): void;
+            loadPolygonNow(polygonId: string): void;
+            _addElementToScene(element: Element): void;
+            /** *
+            Load the map, if it's not already loaded. Returns the old promise if it's already done, so you can safely call it whenever needed.
+    
+            If needed, this could be modified to
+    
+            Returns a Promise that will be Done when the OBJ, MTL and textures have been downloaded, and the objectsDictionary has been generated.
+    
+             **/
+            load(): Promise<MapObject>;
+            _dispose(objectToDispose: Object3D): void;
+            destroy(): void;
+            add(childObjectToAdd: Object3D): void;
+            /**
+                * Convert lat/lon to local map position vector
+                */
+            getPositionLatLon(lat: number, lon: number): Vector3;
+            /**
+                * Previously, each map was centered around 0,0,0 and scaled to fit the map.
+                * With scene manager, each map is positioned and scaled relative to the base map/world
+                * Since most 3D objects (like blue dot) are added to the map via `getPositionLatLon`, they already
+                * have the map's matrix applied, on top of being affected as a child of the map's own transform
+                * This method inverts the map's matrix to resolve the double matrix application issue.
+                * TODO: investigate a better way to handle this
+                */
+            addToObject(child: Object3D): void;
+            /**
+                * Translates objects that are added to the map (such as blue dot), assuming they are added via `getPositionLatLon`,
+                * or `convertTo3DMapPosition`, where the map's matrix has already been applied.
+                */
+            translateChild(child: Object3D, position: Vector3): void;
+            getMapScale(): number;
+            getNorth(): number;
+            enableImageFlipping(polygonId: string, rotation?: number): void;
+            disableAllImageFlipping(): void;
+            /**
+                * Return true if this map has been loaded to the point where it can be
+                * manipulated as a complete object. In synchronous mode, this requires all
+                * loading tasks to be completed, but in async mode, only high-priority
+                * tasks (adding polygons to the world) have to be completed.
+                */
+            isReady(): boolean;
+            /**
+                * Return true if this map has been loaded to the point where the only tasks
+                * remaining are marker tasks.
+                */
+            isFullyLoaded(): boolean;
+            /**
+                * A function that should be called when the map is made visible, in order
+                * to kick off its tasks.
+                */
+            onVisible(): void;
+            /**
+                * A function that should be called when the map is made invisible, in order
+                * to postpone its tasks.
+                */
+            onInvisible(): void;
+            /**
+                * Queue a task on this map that will be executed when the high and low
+                * priority tasks have been processed.
+                */
+            addPendingMarkerTask(marker: string, callback: (...args: any[]) => any): void;
+            /**
+                * Queue a task on this map that must be completed before the map will be
+                * considered `isReady` in synchronous loading mode.
+                */
+            addPendingLowPriorityTask(name: string, callback: (...args: any[]) => any): void;
+            /**
+                * Queue a task on this map that will be queued when the map is loaded, or
+                * immediately if the map has already been loaded.
+                */
+            addPendingMapLoadedTask(name: string, callback: (...args: any[]) => any): void;
+            /**
+                * Queue a task on this map that must be completed before the map will be
+                * considered `isReady`, and will be evaluated before any low-priority
+                * tasks.
+                */
+            _addPendingHighPriorityTask(name: string, callback: (...args: any[]) => any): void;
+            /**
+                * Add a ThreeJS marker to this map object. This should be called through
+                * the `MapView3D`.
+                *
+                * @method addThreeJSMarker
+                * @param {Object} options
+                * @param {Object3D} [options.object] the marker object to add to the scene
+                * @param {Vector3} [options.position=null] if provided, sets the object's position on the map
+                * @param {Euler} [options.rotation=null] if provided, sets the object's rotation relative to the map
+                * @param {Vector3} [options.scale=null] if provided, sets the object's scale relative to the map
+                * @return {ThreeJSMarkerHandle} a unique identifier for the marker
+                */
+            addThreeJSMarker(options: TCreateThreeDMarkerOptions): ThreeJSMarkerHandle;
+            /**
+                * Remove the given `ThreeJSMarker` from this map.
+                *
+                * @method removeThreeJSMarker
+                * @param {ThreeJSMarkerHandle} markerHandle the marker to remove
+                * @return {boolean} true if the marker existed on the map and was removed;
+                *		false if the marker does not exist on the map
+                */
+            removeThreeJSMarker(markerHandle: ThreeJSMarkerHandle): boolean;
+            /**
+                * Remove all `ThreeJSMarker` from this map.
+                *
+                * @method removeThreeJSMarker
+                */
+            _removeThreeJSMarkers(): void;
+            removeLabels(): void;
+            /**
+                * Called when a task group that may be required for map loading completes,
+                * to see if all the relevant task groups have been completed.
+                */
+            _checkIfLoaded(): void;
+            /**
+                * Called when the root ThreeJS object has been created, and child elements
+                * may be added.
+                */
+            _onRootObjectCreated(): void;
+            _popinChildObjects(): void;
+    }
+    /**
+        * A handle to a 3D marker added to a map.
+        *
+        * @class ThreeJSMarkerHandle
+        */
+    export class ThreeJSMarkerHandle {
+            _deleted: boolean;
+            _mapId: string | null;
+            _object: Object3D;
+            constructor(args: {
+                    mapId: string;
+                    object: Object3D;
+            });
+            /**
+                * Return the ThreeJS object associated with this marker, so that it
+                * can be moved around, scaled, etc.
+                *
+                * @property {Object3D} object
+                */
+            get object(): Object3D;
+            _destroy(): void;
+    }
+    export default MapObject;
+}
+
 declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappedin.AssetManager' {
     import { Texture } from 'three';
     import type { MappedinMap } from '@mappedin/react-native-sdk/core/packages/get-venue';
@@ -8683,6 +9036,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
             id?: string;
             anchor?: MARKER_ANCHOR;
             collisionRank?: COLLISION_RANKING_TIERS;
+            layer?: string;
     };
     type TTooltipStyle = {
             top?: string;
@@ -8827,6 +9181,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
         material: MeshLambertMaterial | MeshLambertMaterial[];
         labelMesh?: Mesh;
         imageMesh?: Mesh;
+        sortScore: number | null;
         static materials: {
             [key in string]: MeshLambertMaterial | MeshLambertMaterial[];
         };
@@ -8877,7 +9232,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
             layerGroup: LayerGroup;
             mapGroup: MappedinMapGroup;
             defaultMap: MappedinMap;
-            activeMap: MappedinMap;
+            activeMap?: MappedinMap;
             visibleMap?: MappedinMap;
             readonly startingMap: MappedinMap;
             baseMap: MappedinMap;
@@ -8898,6 +9253,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
                 */
             setBuildingOutlineOpacity(opacity: number): void;
             get activeMapObject(): MapObject;
+            get visibleMapObject(): MapObject;
             get defaultMapObject(): MapObject;
             get baseMapObject(): MapObject;
             state: string;
@@ -8934,6 +9290,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
             setMapAtZoomLevel: number;
             baseMap: MappedinMap;
             preloadDefaultMaps: boolean;
+            keepLayersActiveOnBaseMap: string[];
         };
         constructor(core: ICore, baseMap: MappedinMap);
         resize: () => void;
@@ -8962,10 +9319,18 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/scene-
 declare module '@mappedin/react-native-sdk/core/packages/renderer/private/controllers/PolygonColorsController' {
     import { MappedinPolygon } from '@mappedin/react-native-sdk/core/packages/renderer';
     import { ICore } from '@mappedin/react-native-sdk/core/packages/renderer/private/Core.interface';
+    type SetPolygonColorParam = [MappedinPolygon | string, string, {
+        highlighted?: boolean;
+        visible?: boolean;
+    }?];
     class PolygonColorsController {
         #private;
         constructor(core: ICore);
-        setPolygonColor(polygon: any, color: any, highlighted?: boolean): void;
+        /**
+          * Given a polygon, set it to a specific color.
+          * @param color - color value in hex
+          */
+        setPolygonColor(...params: SetPolygonColorParam): Promise<void>;
         clearPolygonColor(polygon: any): void;
         clearAllPolygonColors(): void;
         setPolygonOutlineColor(color: string): void;
@@ -9158,54 +9523,67 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
     import { FloatingLabel, InternalMarker, SmartTooltip } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     export type Collider = InternalMarker | SmartTooltip | FloatingLabel;
     export type ColliderQuadTree = QuadTree<{
-        collider: Collider;
+            collider: Collider;
     }>;
     export const COLLIDER_STRATEGY_LOW_PRIORITY = "LOW_PRIORITY";
     class SmartCollisionEngine {
-        #private;
-        colliderCanvas: HTMLCanvasElement;
-        debugCanvas: HTMLCanvasElement;
-        colliderCanvasContext: CanvasRenderingContext2D;
-        debugCanvasContext: CanvasRenderingContext2D;
-        collisionEngineContainerEl: HTMLDivElement;
-        stepsX: any;
-        stepsY: any;
-        totalWidth: any;
-        totalHeight: any;
-        project: any;
-        colliders: Map<string, Collider>;
-        offscreenRanges: TRange[];
-        get sortedColliders(): Collider[];
-        initialized: boolean;
-        core: ICore;
-        screen: Rectangle;
-        debouncedUpdate: () => void;
-        constructor(core: ICore);
-        updateStartEvents: {
-            [key: string]: boolean;
-        };
-        updateEndEvents: {
-            [key: string]: boolean;
-        };
-        beginUpdate(): void;
-        init: (container: HTMLDivElement, projectFn: (position: TColliderPosition, mapId: MappedinMap['id']) => {
-            x: number;
-            y: number;
-        }) => void;
-        handleBeginUpdate: (args: any) => void;
-        handleEndUpdate: (args: any) => void;
-        qtree: QuadTree;
-        interactiveCollidersQTree: ColliderQuadTree;
-        recompute: () => void;
-        draw: () => void;
-        reposition: () => void;
-        add: (colliderId: string, collider: Collider) => void;
-        remove: (colliderId: string) => void;
-        updateMap: (colliderId: string, from: string, to: string) => void;
-        update: () => void;
-        resize: (container: any) => void;
-        destroy: () => void;
+            #private;
+            colliderCanvas: HTMLCanvasElement;
+            debugCanvas: HTMLCanvasElement;
+            colliderCanvasContext: CanvasRenderingContext2D;
+            debugCanvasContext: CanvasRenderingContext2D;
+            collisionEngineContainerEl: HTMLDivElement;
+            stepsX: any;
+            stepsY: any;
+            totalWidth: any;
+            totalHeight: any;
+            project: any;
+            colliders: Map<string, Collider>;
+            offscreenRanges: TRange[];
+            get sortedColliders(): Collider[];
+            initialized: boolean;
+            core: ICore;
+            screen: Rectangle;
+            debouncedUpdate: () => void;
+            constructor(core: ICore);
+            updateStartEvents: {
+                    [key: string]: boolean;
+            };
+            updateEndEvents: {
+                    [key: string]: boolean;
+            };
+            beginUpdate(): void;
+            init: (container: HTMLDivElement, projectFn: (position: TColliderPosition, mapId: MappedinMap['id']) => {
+                    x: number;
+                    y: number;
+            }) => void;
+            handleBeginUpdate: (args: any) => void;
+            handleEndUpdate: (args: any) => void;
+            qtree: QuadTree;
+            interactiveCollidersQTree: ColliderQuadTree;
+            recompute: () => void;
+            draw: () => void;
+            reposition: () => void;
+            add: (colliderId: string, collider: Collider) => void;
+            remove: (colliderId: string) => void;
+            updateMap: (colliderId: string, from: string, to: string) => void;
+            update: () => void;
+            resize: (container: any) => void;
+            destroy: () => void;
     }
+    /**
+        * Determines collider visibility based on the current mapId, dynamicFocus options, and visibleLayersInCurrentScene.
+        * 1. If the collider is on the base map and has a layer included in keepLayersActiveOnBaseMap, show it.
+        * 2. Otherwise, if the collider is on the current map and has a layer included in visibleLayersInCurrentScene, show it.
+        * 3. Otherwise, if the collider has no layer and is on the current map, show it.
+        * 4. Otherwise, hide it.
+        */
+    export function isColliderVisible(collider: Collider, mapId: string, dynamicFocusOptions: ICore['options']['dynamicFocus'], visibleLayersInCurrentScene: ICore['visibleLayersInCurrentScene']): boolean;
+    /**
+        * Determines if a collider should be shown on the base map, even when the dynamicFocus has setMap to a different map.
+        * Collider must have an assigned layer included in the keepLayersActiveOnBaseMap option & matching mapId to the base map.
+        */
+    export function shouldKeepActiveOnBaseMap(collider: Collider, dynamicFocusOptions: ICore['options']['dynamicFocus']): boolean;
     export default SmartCollisionEngine;
 }
 
@@ -9399,6 +9777,163 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/Mappe
     export default BlueDotUI;
 }
 
+declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/utils' {
+    import { Box3, Vector3, Object3D, Material } from 'three';
+    import { Mappedin, MapObject, MappedinMap, TMapViewOptions } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
+    import { Camera } from '@mappedin/react-native-sdk/core/packages/renderer/public/api/Camera';
+    /**
+        *	Utils function listing
+        *
+        * - scrubMaterial
+        * - getObjectID
+        * - getObject
+        * - getBoundingBox
+        * - getBiggestBoundingBox
+        * - upackBoundingBox
+        * - getMapScale
+        * - throttle -> taken from lodash.js
+        * - getProjectionScaleFactor
+        * - getZoom
+        */
+    export function isGatewayKey(key: string): boolean;
+    export function getCombinedBoundingBox(objects: Object3D[]): Box3;
+    export function getMapsBoundingBox(maps: MapObject[], mapPadding: number): Box3;
+    export function scrubMaterial(material: Material): void;
+    /**
+        * Takes a Mappedin Object or id and returns the ID, so our functions can take bottomRight
+        * @template T extends string | {id: string}
+        * @param {T} object - input can be object containing id or the id itself
+        * @return {string}
+        */
+    export function getObjectId(object: any): string;
+    /**
+        * Takes a Mappedin object or ID and the array to look in and retuns the Object, so our functions can take both
+        * @template K extends {id: string}
+        * @template T extends K | string
+        * @param {T} obj
+        * @param {Array<K> | undefined} array
+        * @returns {K | undefined}
+        */
+    export function getObject(obj: any, array: any[] | undefined): any;
+    export function getBoundingBox(object: Object3D): Box3;
+    /**
+        * Function pushes the items of the second array onto the first array (inplace).
+        * @template T
+        * @param {Array.<T>} arr1 - base array
+        * @param {Array.<T>} arr2 - array which items will be pushed to arr1
+        */
+    export function appendItems<T>(arr1: T[], arr2: T[]): void;
+    export function getBiggestBoundingBox(objects: Object3D[]): {
+            min: any;
+            max: any;
+    };
+    export function unpackBoundingBox(boundingBox: Box3): Vector3[];
+    export function getMapScale(map: MappedinMap): number;
+    export function getNorth(map: MappedinMap): number;
+    export function throttle<T>(func: () => void, wait: number, options?: any): () => void;
+    export function debounce<T>(func: () => void, wait: number, immediate?: boolean): () => void;
+    export function flatten(list: any[]): any[];
+    export function uniq(arr: any[]): any[];
+    export function toStyleString(styles: Record<string, string>): string;
+    /**
+    /*  getProjectionScaleFactor()
+    /*  finds the scale ratio between screen coordinates and 3D coordinates (in X-Z plane)
+    /*
+                *                                    R
+                *                                  /|
+                *    C : Camera                  /  |
+                *    PQ : Projection Plane     /    |
+                *    OR : Origin             /      |
+                *    F : FOV               /        |
+                *                      Q /          |
+                *                      /|           |
+                *                    /  |           |
+                *                  /    |           |
+                *                /      |           |
+                *              /        |           |
+                *            / F/2      |           |
+                *         C ------------P------------ O
+                *
+                *
+                *   ProjectionScaleFactor = ( OR / PQ )
+                *   PQ = canvasHeight / 2
+                *   CQ = zoom
+                *
+                *   OR / C0 = tan(F/2)
+                *   so OR = CO * tan(F/2)
+                */
+    export function getProjectionScaleFactor(FOV: number, canvasHeight: number, zoom: number): number;
+    /** getZoom
+        *
+        *  C - Camera, OP -- picture plane (canvas), S - origin,
+        *  QR - front side of maps Bounding Box, F: FOV
+        *
+        *                           Z-axis
+        *                     R_____|______
+        *                    /|     |     |
+        *                  /  |     |     |
+        *               P/    |     |     | maps BB
+        *              /|     |     |     |
+        *            /  |     |     |     |
+        *          /    |     |     |     |
+        *        / F    |E    |T    |S    |
+        *    C /--------|-----|-----|-----|------ orthogonal to Y axis, midpoint of focus maps
+        *      \        |     |     |     |
+        *        \      |     |     |     |
+        *          \    |     |     |     |
+        *            \  |     |     |     |
+        *              \|     |     |     |
+        *               O\    |     |     |
+        *                  \  |     |     |
+        *                    \|_____|_____|
+        *                     Q
+        *
+        *
+        * We want to get CS, which is the camera zoom
+        *
+        */
+    export function getZoom(focusBox: Box3, focusBoxHeight: number, FOV: number): number;
+    interface CalculateTwoDProjectionsParams {
+            maps: MapObject[];
+            width: number;
+            height: number;
+            camera: Camera;
+    }
+    export function calculateTwoDProjections({ maps, width, height, camera }: CalculateTwoDProjectionsParams): {
+            min: {
+                    x: number;
+                    y: number;
+            };
+            max: {
+                    x: number;
+                    y: number;
+            };
+    }[];
+    export function splitLine(startNode: Vector3, endNode: Vector3, segments: number): Vector3[];
+    export function isObject(item: any): boolean;
+    export const determineStartingMap: (venue: Mappedin, options: TMapViewOptions) => MappedinMap;
+    export function cyrb53(str: string, seed?: number): number;
+    export function addMarginMultiplierToBoundingBox(bbox: Box3, multiplier: number): Box3;
+    export function tweenPromise({ from, to, duration, easing, delay, onUpdate, onStart, onComplete, }: {
+            from: any;
+            to: any;
+            duration?: number;
+            easing?: any;
+            delay?: number;
+            onUpdate?: (_: any) => void;
+            onStart?: () => void;
+            onComplete?: () => void;
+    }): {
+            start(core: any): Promise<void>;
+    };
+    export const linearEase: (t: number) => number;
+    export const quadEaseIn: (t: number) => number;
+    export const quadEaseOut: (t: number) => number;
+    export function interpolate(value: number, inputMin: number, inputMax: number, outputMin: number, outputMax: number, easeFunc?: (t: number) => number): number;
+    export function interpolateMulti(value: number, inputRange: number[], outputRange: number[], easeFunc?: (t: number) => number): number;
+    export {};
+}
+
 declare module '@mappedin/react-native-sdk/core/packages/renderer/public/MapView' {
     import '../internal/Mappedin.css';
     import { Mappedin, MappedinCoordinate, MappedinLocation, MappedinMap, MappedinNode, MappedinPolygon } from '@mappedin/react-native-sdk/core/packages/get-venue';
@@ -10092,8 +10627,8 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/internal/outdo
             _renderVisibleTiles(): void;
             cachedZoomLevel: number;
             visible: boolean;
-            fadeOut(): any;
-            fadeIn(): any;
+            fadeOut(): Promise<void>;
+            fadeIn(): Promise<void>;
             fetchTiles(): void;
             zoomLevelToAltitudeMap: number[][];
             plane: Object3D;
@@ -10219,7 +10754,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/Core'
             /**
                 * Get all maps that are "visible" in the scene.
                 */
-            get visibleMapsInCurrentScene(): any[];
+            get visibleMapsInCurrentScene(): MappedinMap[];
             get visibleMapObjectsInCurrentScene(): MapObject[];
             /**
                 * Returns all currently visible layers
@@ -10254,15 +10789,15 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/Core'
                 * @param longitude {Number} Longitude of position
                 * @returns A position you can use with a Marker either initially or to update later when the user (for example) moves
                 */
-            getPositionLatLon: (lat: number, lon: number, map?: string | MappedinMap | null) => any;
+            getPositionLatLon: (lat: number, lon: number, map?: string | MappedinMap | null) => Vector3;
             lockNorth: (element: any, offset?: number) => void;
             unlockNorth: (element: any) => void;
             convertTo3DMapPosition: (nodeOrCoordinate: MappedinNode | MappedinCoordinate) => any;
             /**
                 * Converts a 2D x,y screen position into a 3D MappedinCoordinate using projection
                 */
-            convertScreenCoordinateToMapCoordinate: (x: number, y: number, map: MappedinMap) => any;
-            convert3DMapPositionToCoordinate: (coord: any, mapClass?: MappedinMap | null | undefined) => any;
+            convertScreenCoordinateToMapCoordinate: (x: number, y: number, map: MappedinMap) => MappedinCoordinate;
+            convert3DMapPositionToCoordinate: (coord: any, mapClass?: MappedinMap | null | undefined) => MappedinCoordinate;
             getPositionPolygon: (polygon: any) => any;
             getPositionNode: (node: any) => any;
             hideAllLabels: () => void;
@@ -10295,8 +10830,8 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/private/Core'
             determineNewLabelSize: () => void;
             mapSetInProgress: Promise<any>;
             mapSetResolved: any;
-            setMap: (map: string | MappedinMap) => any;
-            setMapWithReason: (map: string | MappedinMap, reason: E_MAP_CHANGED_REASON) => any;
+            setMap: (map: string | MappedinMap) => Promise<any>;
+            setMapWithReason: (map: string | MappedinMap, reason: E_MAP_CHANGED_REASON) => Promise<any>;
             getPolygonsAtScreenCoordinate: (x: number, y: number, options?: TGetPolygonsAtCoordinateOptions) => any;
             getPolygonsAtCoordinate: (coordinate: MappedinCoordinate, options?: TGetPolygonsAtCoordinateOptions) => any;
             getNearestNodeByScreenCoordinate(x: number, y: number, mapOrMapId?: MappedinMap | MappedinMap['id']): MappedinNode;
@@ -10722,7 +11257,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/public/api/Mar
 }
 
 declare module '@mappedin/react-native-sdk/core/packages/renderer/public/api/Paths' {
-    import { MappedinNode } from '@mappedin/react-native-sdk/core/packages/get-venue';
+    import { MappedinCoordinate, MappedinNode } from '@mappedin/react-native-sdk/core/packages/get-venue';
     import { TPathOptions } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     import PathsController, { Path } from '@mappedin/react-native-sdk/core/packages/renderer/private/controllers/PathsController';
     /**
@@ -10754,7 +11289,7 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/public/api/Pat
                 * @param nodes A {@link MappedinNode} array, probably from a {@link MappedinDirections} instance.
                 * @param options
                 */
-            add(nodes: MappedinNode[], options?: TPathOptions): Path;
+            add(nodes: (MappedinNode | MappedinCoordinate)[], options?: TPathOptions): Path;
             /**
                 * Remove a {@link Path} from all maps it exists on.
                 *
@@ -10930,11 +11465,22 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/public/api/Out
                 * @returns
                 */
             setAttributionPosition(position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'): void;
+            /**
+                * Show the outdoor view. Outdoor view must first be enabled in {@link TMapViewOptions} during {@link showVenue}.
+                * See also {@link hide}.
+                */
+            show(): void;
+            /**
+                * Hide the outdoor view. Outdoor view must first be enabled in {@link TMapViewOptions} during {@link showVenue}.
+                * See also {@link show}.
+                */
+            hide(): void;
     }
     export default OutdoorView;
 }
 
 declare module '@mappedin/react-native-sdk/core/packages/renderer/public/api/DynamicFocus' {
+    import { MappedinMap, MappedinMapGroup } from '@mappedin/react-native-sdk/core/packages/get-venue';
     import { DynamicFocusSceneManager } from '@mappedin/react-native-sdk/core/packages/renderer/internal';
     /**
         * @experimental
@@ -10994,6 +11540,14 @@ declare module '@mappedin/react-native-sdk/core/packages/renderer/public/api/Dyn
                 * ```
                 */
             update(): void;
+            /**
+                * Set the default map for a map group. This map will be set when the user pans over the map group.
+                */
+            setDefaultMapForMapGroup(mapGroup: MappedinMapGroup, map: MappedinMap): void;
+            /**
+                * Reset the default map for a map group. This map will be set when the user pans over the map group.
+                */
+            resetDefaultMapForMapGroup(mapGroup: MappedinMapGroup): void;
     }
     export { DynamicFocus };
 }