@mappedin/mappedin-js 5.1.5 → 5.2.0

package/lib/esm/renderer/index.d.ts

@@ -67,6 +67,7 @@ declare module '@mappedin/mappedin-js' {
 }
 
 declare module '@mappedin/mappedin-js/renderer/MapView' {
+    import { Texture } from 'three';
     import './internal/Mappedin.css';
     import { Mappedin, MappedinCoordinate, MappedinLocation, MappedinMap, MappedinNode, MappedinPolygon } from '@mappedin/mappedin-js/get-venue';
     import { E_SDK_EVENT_PAYLOAD, TCreateMarkerOptions, TLabelAllLocationFlatLabelOptions, TLabelAllLocationFloatingLabelOptions, TMapViewOptions, TPathOptions, TCreateTooltipCommonOptions, TCreateTooltipOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
@@ -81,15 +82,29 @@ declare module '@mappedin/mappedin-js/renderer/MapView' {
     import { IFlatLabels } from '@mappedin/mappedin-js/renderer/MapView.FlatLabels';
     import { IFloatingLabels } from '@mappedin/mappedin-js/renderer/MapView.FloatingLabels';
     export enum INTERNAL_EVENT {
-            CAMERA_MOVING = 0,
-            SET_BLUE_DOT_SIZE_FROM_ZOOM = 1,
-            PUBLISH_BLUE_DOT = 2,
-            SET_STATE_SILENT = 3,
-            BLUE_DOT_UPDATE_POSITION = 4,
-            BLUE_DOT_SET_FOLLOWING = 5,
-            CLEAR_MOUSE = 6
+            ON_FIRST_MAP_LOADED = 0,
+            TEXTURE_LOADED = 1,
+            RENDER = 2,
+            RENDER_NOW = 3,
+            UPDATE_FLIPPABLES = 4,
+            SET_MAP_START = 5,
+            SET_MAP = 6,
+            CAMERA_MOVING = 7,
+            SET_BLUE_DOT_SIZE_FROM_ZOOM = 8,
+            PUBLISH_BLUE_DOT = 9,
+            SET_STATE_SILENT = 10,
+            BLUE_DOT_UPDATE_POSITION = 11,
+            BLUE_DOT_SET_FOLLOWING = 12,
+            CLEAR_MOUSE = 13
     }
     export type INTERNAL_EVENT_PAYLOAD = {
+            [INTERNAL_EVENT.SET_MAP_START]: undefined;
+            [INTERNAL_EVENT.ON_FIRST_MAP_LOADED]: undefined;
+            [INTERNAL_EVENT.TEXTURE_LOADED]: Texture;
+            [INTERNAL_EVENT.RENDER]: undefined;
+            [INTERNAL_EVENT.RENDER_NOW]: undefined;
+            [INTERNAL_EVENT.UPDATE_FLIPPABLES]: undefined | boolean;
+            [INTERNAL_EVENT.SET_MAP]: undefined;
             [INTERNAL_EVENT.CAMERA_MOVING]: any;
             [INTERNAL_EVENT.SET_BLUE_DOT_SIZE_FROM_ZOOM]: number;
             [INTERNAL_EVENT.PUBLISH_BLUE_DOT]: undefined;
@@ -1202,6 +1217,12 @@ declare module '@mappedin/mappedin-js/renderer/MapView.types' {
                 * Will be empty if no interactive polygons were clicked.
                 */
             polygons: MappedinPolygon[];
+            /**
+                * A list of {@link MappedinMap}s corresponding to every map that a user's
+                * click passed through. These are in order of first to last intersected.
+                * Will be empty if no maps were clicked.
+                */
+            maps: MappedinMap[];
             /**
                 * Indicates whether the user clicked close to the Blue Dot object on the
                 * map, if present. If Blue Dot is disabled, this will always be false.
@@ -3696,6 +3717,8 @@ declare module '@mappedin/mappedin-js/renderer/Core.interface' {
     import { INTERNAL_EVENT_PAYLOAD } from '@mappedin/mappedin-js/renderer/MapView';
     import { TPadding } from '@mappedin/mappedin-js/renderer';
     import Tween, { Easing } from '@tweenjs/tween.js';
+    import { TaskScheduler } from '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler';
+    import SceneManager from '@mappedin/mappedin-js/renderer/MapView.SceneManager';
     export type TFocusOptionsLegacy = {
             /**
                 * An array of Nodes to focus in on
@@ -3746,10 +3769,14 @@ declare module '@mappedin/mappedin-js/renderer/Core.interface' {
                 * @internal
                 */
             currentScale: number;
+            referenceMap: MappedinMap;
+            taskScheduler: TaskScheduler;
+            sceneManager: SceneManager;
             loadOptions?: TMapViewOptions['loadOptions'];
             imageFlippingEnabled: boolean;
             imageFlippingCache: any;
             cachedPadding: any;
+            getCameraFrameForPoints: any;
             polygonMeshesById: any;
             textLabelsByPolygonId: any;
             renderer: any;
@@ -3847,7 +3874,7 @@ declare module '@mappedin/mappedin-js/renderer/Core.interface' {
             onMapClicked(position: {
                     latitude: number;
                     longitude: number;
-            }, polygons: string[], nearBlueDot: boolean): void;
+            }, polygons: string[], maps: MappedinMap[], nearBlueDot: boolean): void;
             /**
                 * This is called when an interactive Polygon is clicked on.
                 * You will almost certainly want to replace this with your own function in your client app.
@@ -3931,8 +3958,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/blue-dot-manager' {
                 * @param [options.minRadius] The ring around the blue dot will only be drawn if `options.radius` is greater than or equal to this value, in metres. Must be >= 0.
                 * @param [options.radiusUpdateInterval] The width of radius update steps, in metres. For example, if interval is 3 and assume `minRadius` is 8, then the radius will be updated on 8, 11, 14, 17, etc. Must be >= 0.
                 */
-            constructor({ mapManager, mapView, threeDMarkerLayer, core, minRadius, maxRadius, radiusUpdateInterval, radiusTweenOptions }?: {
-                    mapManager: any;
+            constructor({ mapView, threeDMarkerLayer, core, minRadius, maxRadius, radiusUpdateInterval, radiusTweenOptions }?: {
                     mapView: any;
                     threeDMarkerLayer: any;
                     core: any;
@@ -3944,7 +3970,6 @@ declare module '@mappedin/mappedin-js/renderer/internal/blue-dot-manager' {
                             easing: any;
                     } | undefined;
             });
-            mapManager: any;
             mapView: any;
             threeDMarkerLayer: any;
             core: any;
@@ -4620,6 +4645,7 @@ declare module '@mappedin/mappedin-js/renderer/layers/EventSystem' {
         calculateMouseCoordinates: (event: any) => void;
         getMouseRayIntersects: (objects: Object3D | Object3D[]) => any;
         detectPolygonsUnderMouse: () => any[];
+        detectMapsUnderMouse: () => any;
         getMouseMapPosition: () => {
             x: number;
             y: number;
@@ -4640,6 +4666,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.Journey' {
     import { MappedinDirections } from '@mappedin/mappedin-js/get-venue';
     import { TJourneyOptions } from '@mappedin/mappedin-js/renderer/MapView.types';
     import { MapView } from '@mappedin/mappedin-js/renderer';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
     export type TMappedinDirections = {
         distance: number;
         path: INode[];
@@ -4659,7 +4686,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.Journey' {
         accessible: boolean;
         get isMultiFloor(): boolean;
         get mapIdsInvolvedInJourney(): string[];
-        constructor(directions: MappedinDirections | MappedinDirections[], options: TJourneyOptions | undefined, mapView: MapView, mapManager: any);
+        constructor(directions: MappedinDirections | MappedinDirections[], options: TJourneyOptions | undefined, mapView: MapView, core: ICore);
         setStep: (step: any) => void;
         static instance: Journey | null;
         static create(directions: MappedinDirections | MappedinDirections[], options: any, mapView: MapView, mapManager: any): Journey;
@@ -5066,6 +5093,570 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.RenderTasks' {
     }
 }
 
+declare module '@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler' {
+    /**
+        * A function that can be submitted to the Task Scheduler to run each frame for
+        * some provided number of frames. A single update can be repeatedly submitted;
+        * if the number of frames left on the update is less than `frameCount`, it will
+        * be reset to `frameCount`.
+        *
+        * @class FrameUpdate
+        * @private
+        */
+    export class FrameUpdate {
+            /**
+                * Create a new frame update that can be submitted to a scheduler.
+                * 	@constructor
+                *	@param [options] {Object} Options for the update
+                *	@param [options.callback] {function}
+                *		The actual function to run every time this update is scheduled for
+                *		a frame.
+                *	@param [options.frameCount=1] {number}
+                *		How many frames this update should run for when it's submitted to
+                *		a scheduler
+                *	@param [options.ordering=0] {number}
+                *		An ordering value that's used to determine the order in which
+                *		frame updates will be run within a frame; larger numbers will
+                *		be run first
+                *	@param [options.supersededBy=[]] {[FrameUpdate]}
+                *		If this update is scheduled to run in a frame, but another update in
+                *		the provided list is also scheduled to run on that frame, then
+                *		this update will not be run.
+                *	@param [options.name=undefined] {string}
+                *		If provided, an arbitrary name for logging purposes.
+                *	@param [options.userdata] {Any}
+                *		Arbitrary data that you can store along with this update.
+                */
+            constructor(options: {
+                    callback: Function;
+                    frameCount?: number;
+                    ordering?: number;
+                    supersededBy?: Set<never>;
+                    name: string;
+                    userdata?: Record<string, any>;
+            });
+            _callback: Function;
+            _frameCount: number;
+            _ordering: number;
+            _supersededBy: Set<never>;
+            name: string;
+            _remainingFrameCount: number;
+            _lastFrameTime: number;
+            userdata?: Record<string, any>;
+            /**
+                * Return the amount of time that this frame update took to execute during
+                * its most recent execution, in milliseconds. If called during this frame
+                * update, the value returned will be for the previous invocation. If called
+                * before this frame update has been executed at least once, the returned
+                * value is unspecified.
+                *
+                * @method lastFrameTime
+                * @return {number} the previous frame time, in milliseconds
+                */
+            getLastFrameTime(): number;
+    }
+    /**
+        * A task that can be submitted to the Task Scheduler to be run every time
+        * there is a frame update with spare time in the frame.
+        *
+        * @class FrameTask
+        * @private
+        */
+    export class FrameTask {
+            /**
+                * Create a new frame task that can be submitted to a scheduler.
+                * 	@constructor
+                *	@param [options] {Object} Options for the task
+                *	@param [options.callback] {function}
+                *		The actual function to run when this task is scheduled.
+                *	@param [options.group=null] {FrameTaskGroup}
+                *		If provided, a group to which this task will be added when scheduled
+                *	@param [options.priority=0] {number}
+                *		Tasks with higher priority will be taken from the queue before tasks
+                *		with a lower priority.
+                *	@param [options.postponeOnAdd=false] {number}
+                *		If true, this task will not be run until `resumeTask` is called on the
+                *		scheduler.
+                *	@param [options.name=undefined] {string}
+                *		If provided, an arbitrary name for logging purposes.
+                *	@param [options.userdata] {Any}
+                *		Arbitrary data that you can store along with this task.
+                */
+            constructor(options: {
+                    userdata: Record<string, any>;
+                    priority: number;
+                    group?: FrameTaskGroup;
+                    postponeOnAdd: number | boolean;
+                    name: string;
+                    lastFrameTime: number;
+                    callback: Function;
+            });
+            _postponed: number | boolean;
+            userdata: Record<string, any>;
+            _priority: number;
+            _group: FrameTaskGroup | null;
+            name: string;
+            _lastFrameTime: number;
+            _callback: Function;
+            _complete: boolean;
+            _scheduled: boolean;
+            _cancelled: boolean;
+            /**
+                * Return true if this task has been run at least once.
+                *
+                * @method isComplete
+                * @return {boolean}
+                */
+            isComplete(): boolean;
+            /**
+                * Return the amount of time that this frame task took to execute,
+                * in milliseconds. If this task has not yet completed, the returned value
+                * is unspecified.
+                *
+                * @method lastFrameTime
+                * @return {number} the frame time, in milliseconds
+                */
+            getLastFrameTime(): number;
+    }
+    /**
+        * A group of tasks that must all be completed before the group is considered
+        * complete. The tasks will be automatically garbage collected so that references
+        * to the task don't linger.
+        *
+        * @class FrameTaskGroup
+        * @private
+        */
+    export class FrameTaskGroup {
+            /**
+                * Create a new frame task group.
+                *
+                * 	@constructor
+                *	@param [options] {Object} Options for the task group
+                *	@param [options.onComplete] {function}
+                *		A callback that will be triggered once every task in this group
+                *		has been completed. This callback may schedule a task, and the
+                *		scheduler will run that task in the same frame, if there is still
+                *		frame time for it.
+                *	@param [options.priority=0] {number}
+                *		The priority of all the tasks in this group.
+                *	@param [options.postponeOnAdd=false] {number}
+                *		If true, tasks from this task group will not be run until `resumeTask`
+                *		is called on the scheduler with this group.
+                *	@param [options.name=undefined] {string}
+                *		If provided, an arbitrary name for logging purposes.
+                *	@param [options.userdata] {Any}
+                *		Arbitrary data that you can store along with this task group.
+                */
+            constructor(options: {
+                    onComplete?: Function;
+                    priority?: number;
+                    userdata: Record<string, any>;
+                    postponeOnAdd: number | boolean;
+                    name: string;
+            });
+            _postponed: number | boolean;
+            _onComplete: Function;
+            _priority: number;
+            userdata: Record<string, any>;
+            name: string;
+            _tasks: Set<any>;
+            _scheduledTasks: Set<any>;
+            _scheduled: boolean;
+            _cancelled: boolean;
+            /**
+                * Return true if every task in this group has been run at least once.
+                * @method isComplete
+                * @return {boolean}
+                */
+            isComplete(): boolean;
+            /**
+                * Return a list of tasks in this group. This will be a copy of the
+                * underlying task group, so it's safe to mutate the group while
+                * iterating over this array.
+                *
+                * @method tasks
+                * @return {[FrameTask]} list of tasks in this group
+                */
+            getTasks(): any[];
+            /**
+                * Empty this task group. This will trivially satisfy `isComplete`.
+                *
+                * @method clear
+                */
+            clear(): void;
+            /**
+                * Return one arbitrary incomplete task from this group, or undefined if
+                * there are none.
+                *
+                * @method _popTask
+                * @return {FrameTask} arbitrary scheduled task
+                * @private
+                */
+            _popTask(): any;
+    }
+    /**
+        * A timer for the task scheduler that uses real wall-time to determine if there's
+        * enough remaining time in a frame to execute another task.
+        *
+        * @class RealTimeTimer
+        * @private
+        */
+    export class RealTimeTimer {
+            _maxMillisecondsPerFrame: number;
+            _time: number;
+            /**
+                * @constructor
+                * @param [options] {Object} Options for the timer
+                * @param [options.maxMillisecondsPerFrame]
+                *     If the time since the beginning of the frame has been less than
+                *     or equal to this value, then another task may be executed
+                */
+            constructor(options?: {
+                    maxMillisecondsPerFrame?: number;
+            });
+            /**
+                * Begin timing a frame.
+                *
+                * @method beginFrame
+                */
+            beginFrame(): void;
+            /**
+                * If true, there is enough time remaining to execute another task.
+                *
+                * @method hasTimeRemaining
+                * @return {boolean}
+                */
+            hasTimeRemaining(): boolean;
+    }
+    /**
+        * A timer that ticks every time `hasTimeRemaining` is called.
+        *
+        * @class FixedTimer
+        * @private
+        */
+    export class FixedTimer {
+            _ticks: number;
+            maxTasksPerFrame: number;
+            /**
+                * @constructor
+                * @param [options] {Object} Options for the timer
+                * @param [options.maxTasksPerFrame=5]
+                *     The number of tasks that will be exceuted in a single update call.
+                *     Can be modified as the `maxTasksPerFrame` property on this boject.
+                */
+            constructor(options?: {
+                    maxTasksPerFrame?: number;
+            });
+            /**
+                * Begin timing a frame.
+                *
+                * @method beginFrame
+                */
+            beginFrame(): void;
+            /**
+                * If true, there is enough time remaining to execute another task.
+                *
+                * @method hasTimeRemaining
+                * @return {boolean}
+                */
+            hasTimeRemaining(): boolean;
+    }
+    /**
+        * A class that handles scheduling tasks to be performed within the time
+        * constraints of frame updates, triggered using `requestAnimationFrame`.
+        *
+        * Tasks can either be scheduled once per frame (called "frame updates"), or
+        * to execute as many times per frame as there is room for after processing
+        * all frame updates (called "frame tasks").
+        *
+        * Posted tasks will always run during the same frame, assuming there's time to
+        * process them. However, an update or task that posts an update will not run
+        * that update until the next frame.
+        *
+        * @class TaskScheduler
+        * @private
+        */
+    export class TaskScheduler {
+            /**
+                * Construct a new `TaskScheduler` with no tasks scheduled.
+                *
+                * @constructor
+                * @param [options] {Object} Options for the scheduler
+                * @param [options.timer=new RealTimeTimer()]
+                *     Timer that determines whether there is sufficient time left in a frame
+                *     to continue executing tasks
+                * @param [options.performance=false]
+                *     If true, this task scheduler will annotate tasks and frame updates with
+                *     performance information.
+                */
+            constructor(options?: {
+                    timer?: RealTimeTimer;
+                    performance?: boolean;
+            });
+            _raf?: (callback: FrameRequestCallback) => number;
+            _timer: RealTimeTimer;
+            _performance: boolean;
+            _scheduledUpdatesByOrdering: Multimap;
+            _scheduledTasksByPriority: Multimap;
+            _postponedTasks: Set<any>;
+            _requestAnimationFrameHandle: number | null;
+            _updatesToRunThisFrame: any[];
+            _lastFrameTime: number;
+            _updatesRunLastFrame: Set<any>;
+            /**
+                * Empty the task scheduler's queue. All tasks in it will be cancelled.
+                *
+                * @method clear
+                */
+            clear(): void;
+            /**
+                * Destroy this task scheduler and remove all tasks from it.
+                *
+                * @method destroy
+                */
+            destroy(): void;
+            /**
+                * Schedule this task scheduler to execute updates and tasks on the next
+                * available animation frame.
+                *
+                * @method requestAnimationFrame
+                */
+            requestAnimationFrame(): void;
+            /**
+                * Run all scheduled updates, and re-schedule another animation frame if any
+                * scheduled updates still exist. If any scheduled update specifies
+                * `shouldRunTasksAfterCompletion`, this will also run queued tasks until the
+                * frame time runs out.
+                *
+                * @method update
+                * @param timestamp {number} the current animation time, as returned from
+                * `performance.now()`; will be automatically filled in by
+                * `requestAnimationFrame` when it triggers this as a callback
+                */
+            update(timestamp: number): void;
+            /**
+                * Execute all tasks that are currently pending, without regard for the
+                * available frame time.
+                *
+                * @method flushTasks
+                */
+            flushTasks(): void;
+            /**
+                * Return the amount of time elapsed during the last completed frame update,
+                * in milliseconds. This value is unspecified if the task scheduler's
+                * `update` method has not yet run or if the scheduler has been cleared.
+                * If called during a frame update, this will
+                * return the time elapsed during the previous frame update.
+                *
+                * @method lastFrameTime
+                * @return {number} time elapsed during last frame update, in milliseconds
+                */
+            getLastFrameTime(): number;
+            /**
+                * Return a set containing every update that was run during the previous
+                * frame update. This will be empty if the task scheduler's `update` method
+                * has not yet been run or if the scheduler has been cleared.
+                */
+            getUpdatesRunLastFrame(): Set<any>;
+            _executeOneTask(timestamp: number): void;
+            /**
+                * Schedule an update to be run for the next `update.frameCount` frames. If
+                * the update already exists in the scheduler, the update's frame count will
+                * be refreshed to `update.frameCount`. This will also schedule an animation
+                * frame to begin processing the update.
+                *
+                * @method scheduleUpdate
+                * @param task {FrameUpdate} the update to schedule
+                */
+            scheduleUpdate(update: FrameUpdate): void;
+            /**
+                * Schedule a task to be run during a frame update. This will also schedule
+                * an animation frame to begin processing the task queue.
+                *
+                * @method scheduleTask
+                * @param task {FrameTask} the task to schedule
+                */
+            scheduleTask(task: FrameTask): void;
+            /**
+                * If the given update is in the queue, remove it.
+                *
+                * @method cancelUpdate
+                * @param task {FrameUpdate} the update to cancel
+                */
+            cancelUpdate(update: FrameUpdate): void;
+            /**
+                * If the given task or group is in the queue, remove it. Cancelling a
+                * completed task is a no-op.
+                *
+                * Canceling an individual task will also remove it from its task group, if
+                * it isn't already complete.
+                *
+                * @method cancelTask
+                * @param task {FrameTask or FrameTaskGroup} the task to cancel
+                */
+            cancelTask(task: FrameTask | FrameTaskGroup): void;
+            /**
+                * Set the provided task or group not to run, until it's resumed using `resumeTask`.
+                *
+                * Tasks that are in a group can't be postponed individually; instead, call
+                * `postponeTask` with the entire group.
+                *
+                * @method postponeTask
+                * @param task {FrameTask or FrameTaskGroup} the task to postpone
+                */
+            postponeTask(task: FrameTask | FrameTaskGroup): void;
+            /**
+                * Allow a postponed task or task group to resume processing. This will also
+                * request an animation frame to allow the resumed task to be processed.
+                *
+                * Tasks that are in a group can't be resumed individually; instead, call
+                * `resumeTask` with the entire group.
+                *
+                * @method resumeTask
+                * @param task {FrameTask or FrameTaskGroup} the task to resume
+                */
+            resumeTask(task: FrameTask | FrameTaskGroup): void;
+            /**
+                * Change the priority of the given scheduled task or task group.
+                *
+                * @method setTaskPriority
+                * @param task {FrameTask or FrameTaskGroup} the task whose priority will be changed
+                * @param priority {number} the priority to assign the task
+                */
+            setTaskPriority(task: FrameTask | FrameTaskGroup, priority: number): void;
+    }
+    /**
+        * A map that maps a numeric key to a set of values.
+        *
+        * For use in the scheduler, we also maintain a sorted list of keys.
+        *
+        * @class Multimap
+        * @private
+        */
+    class Multimap {
+            /**
+                * @method constructor
+                */
+            constructor();
+            _map: Map<any, any>;
+            _size: number;
+            _sortedKeys: any[];
+            /**
+                * Return true if the set for the given key contains the provided value.
+                *
+                * @method has
+                * @param key {number} the key whose set to check
+                * @param value {Any} the value to check
+                */
+            has(key: number, value: any): any;
+            /**
+                * Return the list of elements at the given key. Make sure not to modify
+                * it, as it will mess up the total element count.
+                *
+                * @method get
+                * @param key {number}
+                * @param value {Set(Any)}
+                */
+            get(key: number): any;
+            /**
+                * @method insert
+                * @param key {number} the key to which another value will be added
+                * @param value {Any} the value to add to the key's set
+                */
+            insert(key: number, value: any): void;
+            /**
+                * @method delete
+                * @param key {number} the key at which the value is stored
+                * @param value {Any} the value to delete
+                */
+            delete(key: number, value: any): void;
+            /**
+                * Remove and return an arbitrary value from the set at the given key.
+                *
+                * @method pop
+                * @param key {number} the key from which to remove a value
+                * @return {Any} arbitrary value from the given key's set, or undefined if
+                * the set at the given key is empty.
+                */
+            pop(key: number): any;
+            /**
+                * Remove and return an arbitrary value from the set corresponding to
+                * the key with the highest numeric value, using the javascript `<`
+                * operator.
+                *
+                * @method popFromMaxKey
+                * @return {Any} arbitrary value from the highest key's set, or undefined
+                * if the map is empty
+                */
+            popFromMaxKey(): any;
+            /**
+                * Return an iterator over every value in this multimap, at every key.
+                * Mutating the multimap during iteration will result in undefined
+                * behaviour.
+                *
+                * @method values
+                * @return {Iterator} iterator over the values in the map
+                */
+            values(): {
+                    [Symbol.iterator]: () => any;
+                    next: () => any;
+            };
+            /**
+                * A list of keys in this set, sorted by numeric value. Not cloned,
+                * for efficiency's sake, so please don't mutate it.
+                *
+                * @method keys
+                * @return {[number]} sorted list of numeric keys in the map
+                */
+            keys(): any[];
+            /**
+                * The number of elements in this multimap, equal to the sum of the sizes
+                * of each key's set of values.
+                *
+                * @property size {number} number of elements in this multimap
+                */
+            get size(): number;
+    }
+    export {};
+}
+
+declare module '@mappedin/mappedin-js/renderer/MapView.SceneManager' {
+    import { MappedinMap } from '@mappedin/mappedin-js/get-venue';
+    import { TCameraTransform, TCameraAnimationOptions } from '@mappedin/mappedin-js/renderer/Camera';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import MapViewScene from '@mappedin/mappedin-js/renderer/MapView.Scene';
+    export type TSceneTransitionOptions = {
+            /**
+                * Map to set as active during the transition. This will decide where the camera will be positioned, as well as which
+                * colliders are enabled.
+                */
+            activeMap?: MappedinMap;
+            verticalDistanceBetweenMaps?: number;
+            /**
+                * Camera options to use when transitioning to the new scene
+                */
+            cameraTransform?: TCameraTransform;
+            cameraAnimationOptions?: TCameraAnimationOptions;
+            /**
+                * Whether to auto focus on the active map or leave the camera where it is.
+                * For single building venues, this should look the same way it did with MapManager
+                * For multi-building venues, this means the camera will not pan over to where the active map
+                * is relative to the world, which may look like broken behavior.
+                * @default true
+                */
+            autoFocusOnActiveMap?: boolean;
+    };
+    class SceneManager {
+            #private;
+            currentScene: MapViewScene;
+            constructor(core: ICore, startingScene: MapViewScene);
+            get currentMap(): MappedinMap;
+            renderGrid(): void;
+            transitionTo(scene: MapViewScene, transitionOptions?: TSceneTransitionOptions): Promise<void>;
+    }
+    export default SceneManager;
+}
+
 declare module '@mappedin/mappedin-js/renderer/internal/shave-text' {
     export type TDrawFn = (ctx: CanvasRenderingContext2D, x: number, y: number) => void;
     type TShave = (str: string, size: number, maxWidth: number, maxLines?: number, lineHeight?: number, options?: {
@@ -5108,6 +5699,7 @@ declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.SmartCollisionE
         core: ICore;
         screen: Rectangle;
         constructor(mapView: any, core: ICore);
+        beginUpdate(): void;
         init: (container: HTMLDivElement, projectFn: ({ position, mapId }: {
             position: any;
             mapId: MappedinMap['id'];
@@ -5335,3 +5927,217 @@ declare module '@mappedin/mappedin-js/renderer/index.rn' {
     export type { TSafeAreaInsets, TCameraTargets, TFocusOnCameraOptions, TCameraTransform, TCameraAnimationOptions } from '@mappedin/mappedin-js/renderer/Camera';
 }
 
+declare module '@mappedin/mappedin-js/renderer/MapView.Scene' {
+    import { MappedinMap } from '@mappedin/mappedin-js/get-venue';
+    import { ICore } from '@mappedin/mappedin-js/renderer/Core.interface';
+    import MapObject from '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject';
+    import { TSceneTransitionOptions } from '@mappedin/mappedin-js/renderer/MapView.SceneManager';
+    class MapViewScene {
+        #private;
+        maps: MappedinMap[];
+        object: any;
+        currentMap: MappedinMap;
+        mapObjects: Map<MappedinMap['id'], MapObject>;
+        constructor(maps: MappedinMap[], core: ICore);
+        /**
+          * Determine each maps position and rotation relative to the refernce map
+          */
+        determineMapPositionAndRotation(map: MappedinMap): {
+            position: any[];
+            scale: number[];
+            rotation: number[];
+        };
+        /** Render scene */
+        render(map: MappedinMap, transitionOptions?: TSceneTransitionOptions, isStartingScene?: boolean): Promise<void>;
+    }
+    export default MapViewScene;
+}
+
+declare module '@mappedin/mappedin-js/renderer/internal/Mappedin.MapObject' {
+    export namespace TASK_PRIORITY {
+            const VISIBLE_MAP_HIGH: number;
+            const VISIBLE_MAP_LOW: number;
+            const VISIBLE_MAP_MARKER: number;
+            const ASYNC_MAP_HIGH: number;
+            const ASYNC_MAP_LOW: number;
+            const ASYNC_MAP_MARKER: number;
+            const MAP_LOADED: number;
+    }
+    export const SCENE_FROM_LIVE_JSON: false;
+    /**
+        * A handle to a 3D marker added to a map.
+        *
+        * @class ThreeJSMarkerHandle
+        */
+    export class ThreeJSMarkerHandle {
+            constructor({ mapId, object }: {
+                    mapId: any;
+                    object: any;
+            });
+            _mapId: any;
+            _object: any;
+            /**
+                * Return the ThreeJS object associated with this marker, so that it
+                * can be moved around, scaled, etc.
+                *
+                * @property {Object3D} object
+                */
+            get object(): any;
+            _destroy(): void;
+    }
+    export default MapObject;
+    class MapObject extends PubSub {
+            constructor(mapClass: any, polygonMeshesById: any, showCount: any, core: any, loadOptions?: {});
+            _flippableImagedById: {};
+            _started: boolean;
+            _loaderPromise: null;
+            _promiseResolve: null;
+            hoverableMeshChildren: any[];
+            objectsDictionary: {};
+            north: null;
+            mapScale: null;
+            object: any;
+            labels: Set<any>;
+            tooltips: Set<any>;
+            markers: Set<any>;
+            textObjects: any[];
+            labelBatchCreator: null;
+            imagesToFlip: any[];
+            seenByCamera: boolean;
+            threeJSMarkers: Map<any, any>;
+            core: any;
+            mapClass: any;
+            polygonMeshesById: any;
+            _showCount: any;
+            loadMethod: string;
+            loadAsync: any;
+            _taskScheduler: any;
+            id: any;
+            mapRenderingStrategy: any;
+            _highPriorityTasks: FrameTaskGroup;
+            _lowPriorityTasks: FrameTaskGroup;
+            _markerTasks: FrameTaskGroup;
+            _mapLoadedTasks: FrameTaskGroup;
+            _visibilityLatch: boolean | null;
+            _objLoadedComplete: boolean;
+            _objLoaded(object: any): any;
+            _objLoadedMerged(object: any): Promise<any>;
+            enableImageFlipping(polygonId: any, rotation: any): void;
+            elements: any;
+            boundingBox: {
+                    min: any;
+                    max: any;
+            } | undefined;
+            loadPolygonNow(polygonId: any): void;
+            _addElementToScene(element: any): 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(): null;
+            loadMethodUsed: string | undefined;
+            _dispose(objectToDispose: any): void;
+            add(childObjectToAdd: any): void;
+            getPositionLatLon(lat: any, lon: any): any;
+            getMapScale(): null;
+            getNorth(): null;
+            disableAllImageFlipping(): void;
+            get visible(): boolean;
+            /**
+                * 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: any, callback: 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: any, callback: 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: any, callback: 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: any, callback: 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: {
+                    object?: any;
+                    position?: any;
+                    rotation?: any;
+                    scale?: any;
+            }): 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;
+            mapLoaded: any;
+            /**
+                * Called when the root ThreeJS object has been created, and child elements
+                * may be added.
+                */
+            _onRootObjectCreated(): void;
+            _popinChildObjects(): void;
+    }
+    import { PubSub } from "@mappedin/mappedin-js/renderer/internal/pub-sub";
+    import { FrameTaskGroup } from "@mappedin/mappedin-js/get-venue/Mappedin.TaskScheduler";
+}
+