@mappedin/blue-dot 6.0.1-beta.61 → 6.5.0-beta.0

package/lib/esm/index.d.ts

@@ -1,867 +1,1256 @@
-// Generated by dts-bundle v0.7.3
-// Dependencies for this module:
-//   ../blue-dot/@mappedin/mappedin-js
-//   ../blue-dot/@packages/internal/common/extensions
-//   ../blue-dot/@packages/internal/common/pubsub
-//   ../blue-dot/type-fest
-//   ../blue-dot/zod
-//   ../blue-dot/three
-
-declare module '@mappedin/blue-dot' {
-    export { BlueDot } from '@mappedin/blue-dot/blue-dot/src/blue-dot';
-    export type { BlueDotEvents, BlueDotEventPayloads, BlueDotPositionUpdate, BlueDotStatus, BlueDotAction, FollowMode, FollowCameraOptions, BlueDotState, BlueDotPositionProcessor, BlueDotPositionUpdateWithFloor, BlueDotUpdateOptions, GeolocationPositionExtended, } from '@mappedin/blue-dot/blue-dot/src/types';
-}
+import { Coordinate, Floor, MapView, Model } from "@mappedin/mappedin-js";
 
-declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
-    import type { Floor, MapView, Model } from '@mappedin/mappedin-js';
-    import { Coordinate } from '@mappedin/mappedin-js';
-    import type { MapViewExtension } from '@packages/internal/common/extensions';
-    import { PubSub } from '@packages/internal/common/pubsub';
-    import type { BlueDotEventPayloads, BlueDotState, BlueDotPositionProcessor, BlueDotPositionUpdate, BlueDotStatus, BlueDotUpdateOptions, FollowCameraOptions, FollowMode, GeolocationPositionExtended, BlueDotUpdateState } from '@mappedin/blue-dot/blue-dot/src/types';
-    import type { ReadonlyDeep } from 'type-fest';
-    /**
-        * Show a Blue Dot indicating the device's position on the map.
-        *
-        * @example
-        * ```ts
-        * import { show3dMap } from '@mappedin/mappedin-js';
-        * import { BlueDot } from '@mappedin/blue-dot';
-        *
-        * const mapView = await show3dMap(...);
-        *
-        * // Enable BlueDot
-        * new BlueDot(mapView).enable();
-        *
-        * // Option 1: Listen for position updates from the device
-        * mapView.BlueDot.on('position-update', (position) => {
-        *   console.log('User position:', position);
-        * });
-        *
-        * // Option 2: Update position manually
-        * new BlueDot(mapView).update({ latitude, longitude, accuracy, floorOrFloorId });
-        *
-        * ```
-        */
-    export class BlueDot implements MapViewExtension<BlueDotState> {
-            #private;
-            /**
-                * Create a new {@link BlueDot} instance.
-                */
-            constructor(mapView: MapView);
-            /**
-                * Get the Model for the BlueDot core element.
-                */
-            get dotModel(): Model | undefined;
-            /**
-                * Get the Model for the accuracy ring.
-                */
-            get accuracyRingModel(): Model | undefined;
-            /**
-                * Get the Model for the heading cone.
-                */
-            get headingConeModel(): Model | undefined;
-            /**
-                * Whether the BlueDot is currently enabled.
-                */
-            get isEnabled(): boolean;
-            /**
-                * The current state of the BlueDot. Can be 'hidden', 'active', 'inactive', or 'disabled'.
-                * Listen for state changes using the 'status-change' event.
-                *
-                * @example
-                * mapView.BlueDot.on('status-change', ({ status }) => {
-                *   if (status === 'active') {
-                *     // BlueDot is visible and tracking
-                *   }
-                * });
-                */
-            get status(): BlueDotStatus;
-            /**
-                * Whether the BlueDot is currently following the user (camera follow mode).
-                */
-            get isFollowing(): boolean;
-            /**
-                * The direction the user is facing in degrees from north clockwise.
-                * @see https://developer.mozilla.org/en-US/docs/Web/API/GeolocationCoordinates/heading
-                */
-            get heading(): GeolocationPosition['coords']['heading'] | undefined;
-            /**
-                * The accuracy of the current position in metres.
-                */
-            get accuracy(): GeolocationPosition['coords']['accuracy'] | undefined;
-            /**
-                * The coordinate of the current position.
-                */
-            get coordinate(): Coordinate | undefined;
-            getState: () => ReadonlyDeep<BlueDotState>;
-            /**
-                * The floor the Blue Dot is currently on. If undefined, the Blue Dot will appear on every floor.
-                */
-            get floor(): Floor | undefined;
-            /**
-                * Enable the Blue Dot. It will be hidden until a position is received either from the browser or by calling {@link BlueDot.update}.
-                * @param options - The options to setup the Blue Dot (see {@link BlueDotOptions}).
-                *
-                * @example Enable with default options
-                * mapView.BlueDot.enable();
-                *
-                * @example Enable with custom color and accuracy ring
-                * mapView.BlueDot.enable({ color: '#00ff00', accuracyRing: { color: '#00ff00', opacity: 0.2 } });
-                *
-                * @see See the [BlueDot Guide](https://developer.mappedin.com/web-sdk/blue-dot) for more information.
-                */
-            enable: (options?: BlueDotUpdateState) => void;
-            /**
-                * Disable the Blue Dot. It will be hidden and no longer update.
-                */
-            disable: () => void;
-            /**
-                * Subscribe to a BlueDot event.
-                * @param eventName The name of the event to listen for.
-                * @param fn The function to call when the event is emitted.
-                */
-            on: PubSub<BlueDotEventPayloads>['on'];
-            /**
-                * Unsubscribe from a BlueDot event.
-                * @param eventName The name of the event to unsubscribe from.
-                * @param fn The function to unsubscribe from the event.
-                */
-            off: PubSub<BlueDotEventPayloads>['off'];
-            /**
-                * Update the BlueDot state after it has been enabled.
-                * This allows overriding previously set values like colors, and other options.
-                * @param options - The options to update
-                *
-                * @example Update color and accuracy ring
-                * mapView.BlueDot.updateState({
-                *   color: '#ff0000',
-                *   accuracyRing: { color: '#ff0000', opacity: 0.5 }
-                * });
-                */
-            updateState: (options: BlueDotUpdateState) => void;
-            /**
-                * Enable or disable the devices's geolocation listener to automatically position the Blue Dot.
-                * If enabled, the device will request permission to access the user's precise location.
-                * @param watch - Whether to enable or disable the listener.
-                */
-            watchDevicePosition: (watch: boolean) => void;
-            /**
-                * Manually override some position properties of the Blue Dot.
-                * Accepts a full GeolocationPosition object or a partial {@link BlueDotPositionUpdate} object.
-                * @example Manually set the accuracy and heading
-                * ```ts
-                * api.BlueDot.update({ accuracy: 10, heading: 90 });
-                * ```
-                * @example Reset accuracy and heading to device values
-                * ```ts
-                * api.BlueDot.update({ accuracy: 'device', heading: 'device' });
-                * ```
-                */
-            update: (position: GeolocationPositionExtended | BlueDotPositionUpdate | undefined, options?: BlueDotUpdateOptions) => void;
-            /**
-                * Set the camera to follow the BlueDot in various modes. User interaction will cancel following automatically.
-                * @param mode The follow mode ('position-only', 'position-and-heading', 'position-and-path-direction', or false to disable).
-                * @param cameraOptions Optional camera options (zoom, pitch, etc.).
-                *
-                * @example
-                * mapView.BlueDot.follow('position-and-heading', { zoomLevel: 21, pitch: 45 });
-                */
-            follow: (mode: FollowMode, cameraOptions?: FollowCameraOptions) => void;
-            /**
-                * Set a position processor callback that allows intercepting and modifying device/geolocation position updates before they are applied.
-                *
-                * **Note**: This processor only applies to automatic position updates from device geolocation.
-                * Manual position updates via `update()` method bypass the processor and are applied directly.
-                *
-                * @param processor - A callback function that receives current state and incoming update. Return undefined to discard the update, or return a modified update object.
-                *
-                * @example Discard inaccurate positions
-                * ```ts
-                * blueDot.setPositionProcessor((current, incoming) => {
-                *   if (incoming.accuracy && incoming.accuracy > 50) {
-                *     return undefined; // Discard update
-                *   }
-                *   return incoming; // Accept update
-                * });
-                * ```
-                *
-                * @example Modify incoming positions
-                * ```ts
-                * blueDot.setPositionProcessor((current, incoming) => {
-                *   // Apply custom smoothing or validation logic
-                *   return {
-                *     ...incoming,
-                *     accuracy: Math.min(incoming.accuracy || 100, 10) // Cap accuracy
-                *   };
-                * });
-                * ```
-                */
-            setPositionProcessor(processor?: BlueDotPositionProcessor): void;
-            destroy: () => void;
-    }
-}
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/primitive.d.ts
 
-declare module '@mappedin/blue-dot/blue-dot/src/types' {
-    import type { Coordinate, Floor } from '@mappedin/mappedin-js';
-    import type z from 'zod';
-    import type { EasingCurve } from '@mappedin/blue-dot/packages/common';
-    import type { positionSchema } from '@mappedin/blue-dot/blue-dot/src/schemas';
-    import type { PartialDeep } from 'type-fest';
-    export type FollowMode = 
-    /** Camera position follows the Blue Dot's position. */
-    'position-only'
-    /** Camera position follows the Blue Dot's position. Camera bearing matches the Blue Dot's heading. */
-     | 'position-and-heading'
-    /** Camera position follows the Blue Dot's position. Camera bearing is calculated based on the Navigation path. */
-     | 'position-and-path-direction'
-    /** Disables follow mode */
-     | false;
-    export type FollowCameraOptions = {
-            /**
-                * @default 21
-                */
-            zoomLevel?: number;
-            /**
-                * @default 45
-                */
-            pitch?: number;
-            /**
-                * Camera bearing in degrees clockwise from North. 0 is North, 90 is East, 180 is South, 270 is West.
-                * This option is only available in 'position-only' mode. In all other modes, the bearing will be calculated automatically.
-                * @default undefined
-                */
-            bearing?: number;
-            /**
-                * @default undefined
-                */
-            elevation?: number;
-            /**
-                * @default 1000
-                */
-            duration?: number;
-            /**
-                * @default 'ease-in-out'
-                */
-            easing?: EasingCurve;
-    };
-    export type BlueDotEventPayloads = {
-            /**
-                * Emitted when the Blue Dot's position is updated.
-                */
-            'position-update': {
-                    floor: Floor | undefined;
-                    heading: GeolocationPosition['coords']['heading'] | undefined;
-                    accuracy: GeolocationPosition['coords']['accuracy'] | undefined;
-                    coordinate: Coordinate;
-            };
-            /**
-                * Emitted when the Blue Dot's status changes.
-                */
-            'status-change': {
-                    /**
-                        * The new status of the Blue Dot.
-                        */
-                    status: BlueDotStatus;
-                    /**
-                        * The action that caused the status change.
-                        */
-                    action: BlueDotAction;
-            };
-            /**
-                * Emitted when the Blue Dot encounters an error.
-                */
-            error: GeolocationPositionError;
-            /**
-                * Emitted when the Blue Dot's following state changes.
-                */
-            'follow-change': {
-                    /**
-                        * Whether the Blue Dot is following the user.
-                        */
-                    following: boolean;
-                    /**
-                        * The mode the Blue Dot is following the user in.
-                        */
-                    mode?: FollowMode;
-            };
-            /**
-                * Emitted when the user clicks on the Blue Dot.
-                */
-            click: {
-                    coordinate: Coordinate;
-            };
-            /**
-                * Emitted when the user hovers over the Blue Dot.
-                */
-            hover: {
-                    coordinate: Coordinate;
-            };
-    };
-    export type BlueDotEvents = keyof BlueDotEventPayloads;
-    export type BlueDotStatus = 'hidden' | 'active' | 'inactive' | 'disabled';
-    export type BlueDotAction = 'timeout' | 'error' | 'position-update' | 'enable' | 'disable' | 'initialize';
-    export type BlueDotState = {
-            /**
-                * The radius of the BlueDot in pixels. The BlueDot will maintain this size clamped to a minimum of 0.35 metres.
-                * @default 10
-                */
-            radius: number;
-            /**
-                * The color of the BlueDot core element.
-                * @default #2266ff
-                */
-            color: string;
-            /**
-                * The color of the BlueDot when it has timed out and gone inactive.
-                * @default #808080
-                */
-            inactiveColor: string;
-            /**
-                * Options for the accuracy ring around the BlueDot.
-                */
-            accuracyRing: {
-                    /**
-                        * The color of the accuracy ring.
-                        * @default #2266ff
-                        */
-                    color: string;
-                    /**
-                        * The opacity of the accuracy ring.
-                        * @default 0.3
-                        */
-                    opacity: number;
-            };
-            /**
-                * Options for the heading directional indicator.
-                */
-            heading: {
-                    /**
-                        * The color of the heading cone.
-                        * @default #2266ff
-                        */
-                    color: string;
-                    /**
-                        * The opacity of the heading cone.
-                        * @default 0.7
-                        */
-                    opacity: number;
-                    /**
-                        * Whether to display the heading cone when the BlueDot is inactive (timed out).
-                        * @default false
-                        */
-                    displayWhenInactive: boolean;
-            };
-            /**
-                * The duration of the timeout in milliseconds.
-                * If the BlueDot does not receive a position update within this time, it will grey out until a position is received.
-                * @default 30000
-                */
-            timeout: number;
-            /**
-                * Whether to watch the device's position.
-                * @default true
-                */
-            watchDevicePosition: boolean;
-            /**
-                * Whether to log debug messages.
-                * @default false
-                */
-            debug: boolean;
-            /**
-                * The maximum acceptable accuracy in meters. Position updates with accuracy exceeding this value will be dropped.
-                * @default 50
-                */
-            accuracyThreshold: number;
-            /**
-                * The initial state of the BlueDot when enabled.
-                * @default 'hidden'
-                */
-            initialState: 'hidden' | 'inactive';
-            /**
-                * @hidden
-                * Whether the BlueDot must remain within the map bounds. Disabling this will disable analytics as well.
-                * @default true
-                */
-            preventOutOfBounds: boolean;
-    };
-    export type BlueDotUpdateState = PartialDeep<BlueDotState>;
-    /**
-        * Position update options for the {@link BlueDot.update} method.
-        */
-    export type BlueDotPositionUpdate = {
-            /**
-                * Latitude to override.
-                * Set to `'device'` to reset to the device's latitude.
-                */
-            latitude?: GeolocationPosition['coords']['latitude'] | 'device' | undefined;
-            /**
-                * Longitude to override.
-                * Set to `'device'` to reset to the device's longitude.
-                */
-            longitude?: GeolocationPosition['coords']['longitude'] | 'device' | undefined;
-            /**
-                * Accuracy to override.
-                * Set to `'device'` to reset to the device's accuracy.
-                * Set to `undefined` to disable the accuracy ring.
-                */
-            accuracy?: GeolocationPosition['coords']['accuracy'] | 'device' | undefined;
-            /**
-                * Heading to override.
-                * Set to `'device'` to reset to the device's heading.
-                * Set to `undefined` to disable the heading indicator.
-                */
-            heading?: GeolocationPosition['coords']['heading'] | 'device' | undefined;
-            /**
-                * Floor or floorId to override.
-                * Set to `'device'` to reset to the device's floor level.
-                * Set to `undefined` to disable floor level and show the BlueDot on all floors.
-                */
-            floorOrFloorId?: Floor | string | 'device' | undefined;
-            /**
-                * Timestamp of the position update in milliseconds.
-                */
-            timestamp?: number;
-    };
-    export type BlueDotPositionUpdateWithFloor = Omit<BlueDotPositionUpdate, 'floorOrFloorId'> & {
-            floor?: Floor | 'device' | undefined;
-    };
-    export type ParsedBlueDotPosition = z.infer<typeof positionSchema>;
-    export type BlueDotPositionProcessor = (current: BlueDotPositionUpdateWithFloor, incoming: BlueDotPositionUpdateWithFloor) => BlueDotPositionUpdateWithFloor | undefined;
-    export type StateTransitions = {
-            [Action in BlueDotAction]?: BlueDotStatus;
-    };
-    export type StateMachine = {
-            [State in BlueDotStatus]: {
-                    actions: StateTransitions;
-            };
-    };
-    /**
-        * Options for the BlueDot update method.
-        */
-    export type BlueDotUpdateOptions = {
-            /**
-                * If true, maintains the current state and skips timers and analytics for this update.
-                * @default false
-                */
-            silent?: boolean;
-            /**
-                * If true, animates the position change. If false, updates immediately.
-                * @default true
-                */
-            animate?: boolean;
-    };
-    export type GeolocationPositionExtended = GeolocationPosition & {
-            coords: GeolocationPosition['coords'] & {
-                    readonly floorLevel?: number;
-            };
-    };
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/observable-like.d.ts
+declare global {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
 }
 
-declare module '@mappedin/blue-dot/packages/common' {
-    import Logger from '@mappedin/blue-dot/packages/common/Mappedin.Logger';
-    export * from '@mappedin/blue-dot/packages/common/errors';
-    export * from '@mappedin/blue-dot/packages/common/utils';
-    export * from '@mappedin/blue-dot/packages/common/async';
-    export * from '@mappedin/blue-dot/packages/common/assert';
-    export * from '@mappedin/blue-dot/packages/common/random-id';
-    export { PubSub } from '@mappedin/blue-dot/packages/common/pubsub';
-    export { SafeStorage, SESSION_ID_KEY, DEVICE_ID_KEY } from '@mappedin/blue-dot/packages/common/storage';
-    export { Logger };
-    export * from '@mappedin/blue-dot/packages/common/color';
-    export * from '@mappedin/blue-dot/packages/common/interpolate';
+/**
+@remarks
+The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
+As well, some guidance on making an `Observable` to not include `closed` property.
+@see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
+@see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
+@see https://github.com/benlesh/symbol-observable#making-an-object-observable
+
+@category Observable
+*/
+
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
 }
 
-declare module '@mappedin/blue-dot/blue-dot/src/schemas' {
-    import z from 'zod';
-    export const geolocationPositionSchema: z.ZodObject<{
-        coords: z.ZodObject<{
-            latitude: z.ZodNumber;
-            longitude: z.ZodNumber;
-            accuracy: z.ZodNumber;
-            altitude: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-            altitudeAccuracy: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-            heading: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-            speed: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-            floorLevel: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-        }, z.core.$strip>;
-        timestamp: z.ZodNumber;
-    }, z.core.$strip>;
-    export const positionSchema: z.ZodObject<{
-        latitude: z.ZodNumber;
-        longitude: z.ZodNumber;
-        floor: z.ZodOptional<z.ZodAny>;
-        accuracy: z.ZodOptional<z.ZodNumber>;
-        heading: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-        timestamp: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? (keyof { [Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+: never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
 }
 
-declare module '@mappedin/blue-dot/packages/common/Mappedin.Logger' {
-    export const MI_DEBUG_KEY = "mi-debug";
-    export const MI_ERROR_LABEL = "[MappedinJS]";
-    export enum E_SDK_LOG_LEVEL {
-        LOG = 0,
-        WARN = 1,
-        ERROR = 2,
-        SILENT = 3
-    }
-    export function createLogger(name?: string, { prefix }?: {
-        prefix?: string | undefined;
-    }): {
-        logState: E_SDK_LOG_LEVEL;
-        log(...args: any[]): void;
-        warn(...args: any[]): void;
-        error(...args: any[]): void;
-        assert(...args: any[]): void;
-        time(label: string): void;
-        timeEnd(label: string): void;
-        setLevel(level: E_SDK_LOG_LEVEL): void;
-    };
-    const Logger: {
-        logState: E_SDK_LOG_LEVEL;
-        log(...args: any[]): void;
-        warn(...args: any[]): void;
-        error(...args: any[]): void;
-        assert(...args: any[]): void;
-        time(label: string): void;
-        timeEnd(label: string): void;
-        setLevel(level: E_SDK_LOG_LEVEL): void;
-    };
-    export function setLoggerLevel(level: E_SDK_LOG_LEVEL): void;
-    export default Logger;
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
 }
 
-declare module '@mappedin/blue-dot/packages/common/errors' {
-    /**
-        * @internal
-        */
-    export class MappedinError extends Error {
-            constructor(message: string, label?: string);
-    }
-    /**
-        * @internal
-        */
-    export class MappedinRenderError extends MappedinError {
-            constructor(message: string, label?: string);
-    }
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-never.d.ts
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/is-any.d.ts
+// Can eventually be replaced with the built-in once this library supports
+// TS5.4+ only. Tracked in https://github.com/sindresorhus/type-fest/issues/848
+type NoInfer<T> = T extends infer U ? U : never;
+
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
 }
 
-declare module '@mappedin/blue-dot/packages/common/utils' {
-    import { Box2 } from 'three';
-    import type { Box3 } from 'three';
-    export function findMapWithElevationClosestToZero<T extends {
-            elevation?: number;
-    }>(maps: T[]): T | undefined;
-    /**
-        * Omit properites from object
-        */
-    export function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keysToOmit: K[]): Omit<T, K>;
-    export function decodeAccessToken(accessToken: string): {
-            sub: string;
-            aud: string[];
-            capabilities: Record<string, any>;
-    };
-    export function toRadians(degrees: number): number;
-    export function toDegrees(radians: number): number;
-    export function round(value: number, decimals: number): number;
-    export function euclideanModulo(value: number, modulus: number): number;
-    /**
-        * Position from our SDKs may be tuple of longitude and latitude optionally followed by altitude.
-        */
-    type Position = [number, number] | [number, number, number?] | number[];
-    /**
-        * Calculates the approximate distance between two geographic coordinates on Earth's surface.
-        *
-        * This function uses the equirectangular approximation method to compute the distance, which simplifies
-        * the math and speeds up calculations, but is less accurate over long distances compared to other methods
-        * like the haversine formula.
-        *
-        * @param point1 - The first point's longitude and latitude as [longitude, latitude].
-        * @param point1 - The second point's longitude and latitude as [longitude, latitude].
-        * @return The approximate distance between the two points in meters.
-        */
-    export function haversineDistance([lon1, lat1]: Position, [lon2, lat2]: Position): number;
-    /**
-        * Calculates the bearing clockwise from North between two geographic coordinates on Earth's surface.
-        * 0 is North, 90 is East, 180 is South, 270 is West.
-        *
-        * @param point1 - The first point's longitude and latitude as [longitude, latitude].
-        * @param point2 - The second point's longitude and latitude as [longitude, latitude].
-        * @returns The forward bearing in degrees from point1 to point2, measured clockwise from true North.
-        */
-    export function getForwardBearing([lon1, lat1]: Position, [lon2, lat2]: Position): number;
-    /**
-        *
-        * Normalizes the start and end rotations to the range 0 to 2 PI and ensures the shortest path for rotation.
-        *
-        * @param startRotation - The start rotation in radians
-        * @param targetRotation - The target rotation in radians
-        * @returns Start and end rotations for the tween.
-        */
-    export function shortestTweenRotation(startRotation: number, targetRotation: number): {
-            start: number;
-            end: number;
-    };
-    export function isFiniteBox(box: Box2 | Box3): boolean;
-    export { clampWithWarning } from '@mappedin/blue-dot/packages/common/math-utils';
-    export { arraysEqual } from '@mappedin/blue-dot/packages/common/array-utils';
-    export function isBrowser(): boolean;
-    /**
-        * Calculates the simple Euclidean distance between two geographic coordinates.
-        *
-        * This treats longitude and latitude as Cartesian coordinates on a flat plane.
-        * It's the fastest distance calculation but least accurate for geographic data.
-        * Best used for relative distance comparisons rather than actual measurements.
-        *
-        * @param point1 - The first point's longitude and latitude as [longitude, latitude].
-        * @param point2 - The second point's longitude and latitude as [longitude, latitude].
-        * @returns The Euclidean distance between the two points in meters.
-        */
-    export function euclideanDistance(point1: Position, point2: Position): number;
-    /**
-        * Calculates the approximate distance between two geographic coordinates on Earth's surface.
-        *
-        * This function uses the equirectangular approximation method to compute the distance, which simplifies
-        * the math and speeds up calculations, but is less accurate over long distances compared to other methods
-        * like the haversine formula.
-        *
-        * @param point1 - The first point's longitude and latitude as [longitude, latitude].
-        * @param point2 - The second point's longitude and latitude as [longitude, latitude].
-        * @returns The approximate distance between the two points in meters.
-        */
-    export function equirectangularDistance(point1: Position, point2: Position): number;
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
 }
 
-declare module '@mappedin/blue-dot/packages/common/async' {
-    export function debounce<T extends (...args: any[]) => void>(func: T, wait: number, immediate?: boolean): (...args: Parameters<T>) => void;
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/omit-index-signature.d.ts
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
 }
 
-declare module '@mappedin/blue-dot/packages/common/assert' {
-    /**
-        * Options for assertExists function
-        */
-    export interface AssertExistsOptions {
-            /** Name of the value being checked (for better error messages) */
-            valueName?: string;
-            /** Custom error message to use instead of the default */
-            customMessage?: string;
-            /** Error class to use (defaults to AssertionError) */
-            errorClass?: new (message: string) => Error;
-            /** Whether to capture and format the stack trace (defaults to true) */
-            captureStackTrace?: boolean;
-    }
-    /**
-        * Custom error class for assertions to make stack traces more identifiable
-        */
-    export class AssertionError extends Error {
-            name: string;
-            constructor(message: string);
-    }
-    /**
-        * Asserts that a value is not null or undefined.
-        * @param value The value to check
-        * @param options Optional configuration for the assertion
-        */
-    export function assertExists<T>(value: T, options?: AssertExistsOptions): asserts value is NonNullable<T>;
-    /**
-        * Asserts that an object is an instance of a specific class.
-        * @param obj The object to check
-        * @param className The class constructor to check against
-        * @param errorMessage Optional custom error message
-        */
-    export function assertInstanceOf<T>(obj: unknown, className: new (...args: any[]) => T, errorMessage?: string): asserts obj is T;
-    /**
-        * Asserts that an object has a specific 'type' property value.
-        * @param obj The object to check
-        * @param expectedType The expected value of the 'type' property
-        * @param errorMessage Optional custom error message
-        */
-    export function assertType<T extends {
-            type: string;
-    }, P extends T['type']>(obj: T | undefined, expectedType: P, errorMessage?: string): asserts obj is Extract<T, {
-            type: P;
-    }>;
-    /**
-        * Retrieves an entity from a map and asserts it is of a specific type.
-        * @param map The map containing entities
-        * @param entityId The ID of the entity to retrieve
-        * @param expectedType The class constructor the entity should be an instance of
-        * @returns The entity cast to the expected type
-        */
-    export function getEntityAsType<T>(map: Map<string | number, unknown>, entityId: string | number, expectedType: new (...args: any[]) => T): T;
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/pick-index-signature.d.ts
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see OmitIndexSignature
+@category Object
+*/
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = { [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source;
+
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+interface Foo {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
 }
 
-declare module '@mappedin/blue-dot/packages/common/random-id' {
-    /**
-      * Returns a UUIDv4-like ID without relying on a CSPRNG as we don't need it for these purposes.
-      * @hidden
-      */
-    export const randomId: () => string;
-    export function cyrb53(str: string, seed?: number): number;
-    export function shortId(): string;
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+@category Object
+*/
+type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/if-any.d.ts
+/**
+An if-else-like type that resolves depending on whether the given type is `any`.
+
+@see {@link IsAny}
+
+@example
+```
+import type {IfAny} from 'type-fest';
+
+type ShouldBeTrue = IfAny<any>;
+//=> true
+
+type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/internal/object.d.ts
+
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key] }> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/partial-deep.d.ts
+/**
+@see {@link PartialDeep}
+*/
+type PartialDeepOptions = {
+  /**
+  Whether to affect the individual elements of arrays and tuples.
+  	@default false
+  */
+  readonly recurseIntoArrays?: boolean;
+
+  /**
+  Allows `undefined` values in non-tuple arrays.
+  	- When set to `true`, elements of non-tuple arrays can be `undefined`.
+  - When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
+  	@default true
+  	@example
+  You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+  	```
+  import type {PartialDeep} from 'type-fest';
+  	type Settings = {
+  	languages: string[];
+  };
+  	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
+  	partialSettings.languages = [undefined]; // Error
+  partialSettings.languages = []; // Ok
+  ```
+  */
+  readonly allowUndefinedInNonTupleArrays?: boolean;
+};
+type DefaultPartialDeepOptions = {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: true;
+};
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400
+	},
+	autocomplete: false,
+	autosave: true
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
 }
 
-declare module '@mappedin/blue-dot/packages/common/pubsub' {
-    /**
-        * Generic PubSub class implementing the Publish-Subscribe pattern for event handling.
-        *
-        * @template EVENT_PAYLOAD - The type of the event payload.
-        * @template EVENT - The type of the event.
-        */
-    export class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EVENT_PAYLOAD> {
-            /**
-                * @private
-                * @internal
-                */
-            publish<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, data?: EVENT_PAYLOAD[EVENT_NAME]): void;
-            /**
-                * Subscribe a function to an event.
-                *
-                * @param eventName An event name which, when fired, will call the provided
-                * function.
-                * @param fn A callback that gets called when the corresponding event is fired. The
-                * callback will get passed an argument with a type that's one of event payloads.
-                * @example
-                * // Subscribe to the 'click' event
-                * const handler = (event) => {
-                *  const { coordinate } = event;
-                *  const { latitude, longitude } = coordinate;
-                * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
-                * };
-                * map.on('click', handler);
-                */
-            on<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
-                    data: null;
-            } ? EVENT_PAYLOAD[EVENT_NAME]['data'] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
-            /**
-                * Unsubscribe a function previously subscribed with {@link on}
-                *
-                * @param eventName An event name to which the provided function was previously
-                * subscribed.
-                * @param fn A function that was previously passed to {@link on}. The function must
-                * have the same reference as the function that was subscribed.
-                * @example
-                * // Unsubscribe from the 'click' event
-                * const handler = (event) => {
-                * 	console.log('Map was clicked', event);
-                * };
-                * map.off('click', handler);
-                */
-            off<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
-                    data: null;
-            } ? EVENT_PAYLOAD[EVENT_NAME]['data'] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
-            /**
-                * @private
-                * @internal
-                */
-            destroy(): void;
-    }
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Settings = {
+	languages: string[];
 }
 
-declare module '@mappedin/blue-dot/packages/common/storage' {
-    export const SESSION_DATA_KEY: "mi-session-data";
-    export const LOCAL_DATA_KEY: "mi-local-data";
-    export const SESSION_ID_KEY: "id";
-    export const DEVICE_ID_KEY: "deviceId";
-    export type SessionData = {
-        [SESSION_ID_KEY]: string;
-        [prop: string]: unknown;
-    };
-    export type LocalData = {
-        [DEVICE_ID_KEY]: string;
-        [prop: string]: unknown;
-    };
-    export class SafeStorage {
-        #private;
-        static getInstance(): SafeStorage;
-        static ___clearInstance(): void;
-        saveSessionData<T extends keyof SessionData>(key: T, data: SessionData[T]): boolean;
-        loadSessionData<T extends keyof SessionData>(key: T): SessionData[T] extends undefined ? SessionData[T] | undefined : SessionData[T];
-        saveLocalData<T extends keyof LocalData>(key: T, data: LocalData[T]): boolean;
-        loadLocalData<T extends keyof LocalData>(key: T): LocalData[T] extends undefined ? LocalData[T] | undefined : LocalData[T];
-    }
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
+	languages: [undefined]
+};
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : IsNever<keyof T> extends true // For functions with no properties
+? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+? Options['recurseIntoArrays'] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+? ReadonlyArray<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
+: T // If they don't opt into array testing, just use the original type
+: PartialObjectDeep<T, Options> : unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType$1, ValueType$1, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType$1, Options>, _PartialDeep<ValueType$1, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType$1, ValueType$1, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType$1, Options>, _PartialDeep<ValueType$1, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends ((...arguments_: any) => unknown) ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({ [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options> });
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@4.41.0/node_modules/type-fest/source/readonly-deep.d.ts
+/**
+Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
+
+This is useful when a deeply nested structure needs to be exposed as completely immutable, for example, an imported JSON module or when receiving an API response that is passed around.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	"foo": ["bar"]
 }
 
-declare module '@mappedin/blue-dot/packages/common/color' {
-    export const X11_COLOR_NAMES_SET: Set<string>;
-    /**
-        * Check if a string is a valid X11 color name, as defined in ThreeJS Color.NAMES
-        * @param color - The color string to check.
-        * @returns True if the color is a valid X11 color name, false otherwise.
-        */
-    export const isX11Color: (color: string) => boolean;
-    /**
-        * Check if a string is a valid hex color.
-        * @param color - The color string to check.
-        * @returns True if the color is a valid hex color, false otherwise.
-        */
-    export const isHexColor: (color: string) => boolean;
+// main.ts
+import type {ReadonlyDeep} from 'type-fest';
+import dataJson = require('./data.json');
+
+const data: ReadonlyDeep<typeof dataJson> = dataJson;
+
+export default data;
+
+// test.ts
+import data from './main';
+
+data.foo.push('bar');
+//=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
+```
+
+Note that types containing overloaded functions are not made deeply readonly due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type ReadonlyDeep<T> = T extends BuiltIns ? T : T extends (new (...arguments_: any[]) => unknown) ? T // Skip class constructors
+: T extends ((...arguments_: any[]) => unknown) ? {} extends ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> :
+// Identify tuples to avoid converting them to arrays inadvertently; special case `readonly [...never[]]`, as it emerges undesirably from recursive invocations of ReadonlyDeep below.
+T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [infer U, ...infer V] ? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>] : T extends readonly [...infer U, infer V] ? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? ReadonlyObjectDeep<T> : unknown;
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyMapDeep<KeyType$1, ValueType$1> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType$1>, ReadonlyDeep<ValueType$1>>>;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlySetDeep<ItemType$1> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType$1>>>;
+
+/**
+Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
+*/
+type ReadonlyObjectDeep<ObjectType extends object> = { readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]> };
+//#endregion
+//#region ../packages/common/extensions.d.ts
+interface MapViewExtension<T> {
+  enable(options?: PartialDeep<T>): void;
+  disable(): void;
+  get isEnabled(): boolean;
+  destroy(): void;
+}
+//#endregion
+//#region ../packages/common/pubsub.d.ts
+/**
+ * Generic PubSub class implementing the Publish-Subscribe pattern for event handling.
+ *
+ * @template EVENT_PAYLOAD - The type of the event payload.
+ * @template EVENT - The type of the event.
+ */
+declare class PubSub<EVENT_PAYLOAD, EVENT extends keyof EVENT_PAYLOAD = keyof EVENT_PAYLOAD> {
+  /**
+   * @private
+   * @internal
+   */
+  private _subscribers;
+  /**
+   * @private
+   * @internal
+   */
+  private _destroyed;
+  /**
+   * @private
+   * @internal
+   */
+  publish<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, data?: EVENT_PAYLOAD[EVENT_NAME]): void;
+  /**
+   * Subscribe a function to an event.
+   *
+   * @param eventName An event name which, when fired, will call the provided
+   * function.
+   * @param fn A callback that gets called when the corresponding event is fired. The
+   * callback will get passed an argument with a type that's one of event payloads.
+   * @example
+   * // Subscribe to the 'click' event
+   * const handler = (event) => {
+   *  const { coordinate } = event;
+   *  const { latitude, longitude } = coordinate;
+   * 	console.log(`Map was clicked at ${latitude}, ${longitude}`);
+   * };
+   * map.on('click', handler);
+   */
+  on<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
+    data: null;
+  } ? EVENT_PAYLOAD[EVENT_NAME]['data'] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
+  /**
+   * Unsubscribe a function previously subscribed with {@link on}
+   *
+   * @param eventName An event name to which the provided function was previously
+   * subscribed.
+   * @param fn A function that was previously passed to {@link on}. The function must
+   * have the same reference as the function that was subscribed.
+   * @example
+   * // Unsubscribe from the 'click' event
+   * const handler = (event) => {
+   * 	console.log('Map was clicked', event);
+   * };
+   * map.off('click', handler);
+   */
+  off<EVENT_NAME extends EVENT>(eventName: EVENT_NAME, fn: (payload: EVENT_PAYLOAD[EVENT_NAME] extends {
+    data: null;
+  } ? EVENT_PAYLOAD[EVENT_NAME]['data'] : EVENT_PAYLOAD[EVENT_NAME]) => void): void;
+  /**
+   * @private
+   * @internal
+   */
+  destroy(): void;
+}
+//#endregion
+//#region ../packages/common/interpolate.d.ts
+declare const EASING_CURVES: readonly ["ease-in", "ease-out", "ease-in-out", "linear"];
+type EasingCurve = (typeof EASING_CURVES)[number];
+//#endregion
+//#region src/types.d.ts
+type FollowMode = /** Camera position follows the Blue Dot's position. */
+'position-only'
+/** Camera position follows the Blue Dot's position. Camera bearing matches the Blue Dot's heading. */ | 'position-and-heading'
+/** Camera position follows the Blue Dot's position. Camera bearing is calculated based on the Navigation path. */ | 'position-and-path-direction'
+/** Disables follow mode */ | false;
+type FollowCameraOptions = {
+  /**
+   * @default 21
+   */
+  zoomLevel?: number;
+  /**
+   * @default 45
+   */
+  pitch?: number;
+  /**
+   * Camera bearing in degrees clockwise from North. 0 is North, 90 is East, 180 is South, 270 is West.
+   * This option is only available in 'position-only' mode. In all other modes, the bearing will be calculated automatically.
+   * @default undefined
+   */
+  bearing?: number;
+  /**
+   * @default undefined
+   */
+  elevation?: number;
+  /**
+   * @default 1000
+   */
+  duration?: number;
+  /**
+   * @default 'ease-in-out'
+   */
+  easing?: EasingCurve;
+};
+type BlueDotEventPayloads = {
+  /**
+   * Emitted when the Blue Dot's position is updated either from the device's geolocation API or by calling {@link BlueDot.update}.
+   * see {@link BlueDot.watchDevicePosition} for more details.
+   */
+  'position-update': {
+    floor: Floor | undefined;
+    heading: GeolocationPosition['coords']['heading'] | undefined;
+    accuracy: GeolocationPosition['coords']['accuracy'] | undefined;
+    coordinate: Coordinate;
+  };
+  /**
+   * Emitted when the device's orientation changes and the Blue Dot's heading is updated.
+   * see {@link BlueDot.watchDeviceOrientation} for more details.
+   */
+  'device-orientation-update': {
+    heading: GeolocationPosition['coords']['heading'] | undefined;
+  };
+  /**
+   * Emitted when the Blue Dot's status changes.
+   */
+  'status-change': {
     /**
-        * Check if a string is a valid RGB/RGBA color.
-        * @param color - The color string to check.
-        * @returns True if the color is a valid RGB/RGBA color, false otherwise.
-        */
-    export const isRgbColor: (color: string) => boolean;
+     * The new status of the Blue Dot.
+     */
+    status: BlueDotStatus;
     /**
-        * Check if a string is a valid HSL/HSLA color.
-        * @param color - The color string to check.
-        * @returns True if the color is a valid HSL/HSLA color, false otherwise.
-        */
-    export const isHslColor: (color: string) => boolean;
+     * The action that caused the status change.
+     */
+    action: BlueDotAction;
+  };
+  /**
+   * Emitted when the Blue Dot encounters an error.
+   */
+  error: GeolocationPositionError;
+  /**
+   * Emitted when the Blue Dot's following state changes.
+   */
+  'follow-change': {
     /**
-        * Check if a string is a valid ThreeJS color. Can be hex, rgb, rgba, hsl, hsla, or X11 color name.
-        * @param color - The color string to check.
-        * @returns True if the color is a valid ThreeJS color, false otherwise.
-        */
-    export const isColor: (color: string) => boolean;
+     * Whether the Blue Dot is following the user.
+     */
+    following: boolean;
     /**
-        * Convert a color string to an array of RGB values.
-        * @param color - The color string to convert.
-        * @returns The array of RGB values.
-        */
-    export const stringToRgbArray: (color: string) => [number, number, number];
+     * The mode the Blue Dot is following the user in.
+     */
+    mode?: FollowMode;
+  };
+  /**
+   * Emitted when the user clicks on the Blue Dot.
+   */
+  click: {
+    coordinate: Coordinate;
+  };
+  /**
+   * Emitted when the user hovers over the Blue Dot.
+   */
+  hover: {
+    coordinate: Coordinate;
+  };
+};
+type BlueDotEvents = keyof BlueDotEventPayloads;
+type BlueDotStatus = 'hidden' | 'active' | 'inactive' | 'disabled';
+type BlueDotAction = 'timeout' | 'error' | 'position-update' | 'enable' | 'disable' | 'initialize';
+type BlueDotState = {
+  /**
+   * The radius of the BlueDot in pixels. The BlueDot will maintain this size clamped to a minimum of 0.35 metres.
+   * @default 10
+   */
+  radius: number;
+  /**
+   * The color of the BlueDot core element.
+   * @default #2266ff
+   */
+  color: string;
+  /**
+   * The color of the BlueDot when it has timed out and gone inactive.
+   * @default #808080
+   */
+  inactiveColor: string;
+  /**
+   * Options for the accuracy ring around the BlueDot.
+   */
+  accuracyRing: {
     /**
-        * Convert an array of RGB values to a hex string.
-        * @param rgb - The array of RGB values to convert.
-        * @returns The hex string representation of the RGB values.
-        */
-    export const rgbArrayToString: (rgb: [number, number, number]) => string;
-}
-
-declare module '@mappedin/blue-dot/packages/common/interpolate' {
-    export const EASING_CURVES: readonly ["ease-in", "ease-out", "ease-in-out", "linear"];
-    export type EasingCurve = (typeof EASING_CURVES)[number];
+     * The color of the accuracy ring.
+     * @default #2266ff
+     */
+    color: string;
     /**
-        * Validates if a value is a valid easing curve
-        * @param value The value to validate
-        * @returns True if the value is a valid easing curve
-        */
-    export function isValidEasingCurve(value: unknown): value is EasingCurve;
-    export const linearEase: (t: number) => number;
-    export const quadEaseIn: (t: number) => number;
-    export const easeIn: (x: number) => number;
-    export const quadEaseOut: (t: number) => number;
-    export function interpolate(value: number, inputMin: number, inputMax: number, outputMin: number, outputMax: number, easeFunc?: EasingCurve | ((t: number) => number)): number;
+     * The opacity of the accuracy ring.
+     * @default 0.3
+     */
+    opacity: number;
+  };
+  /**
+   * Options for the heading directional indicator.
+   */
+  heading: {
     /**
-        * Return the closest range within an ordered set of values that a given value falls within. If the given value is
-        * exactly within a range, returns the index of the range. If the given value is less than the first value in the range,
-        * returns 0. If the given value is greater than the last value in the range, returns the last range (lastIndex - 1).
-        */
-    export function getInterpolationBreakpoint(value: number, range: number[]): number;
-    export function interpolateMulti(value: number, inputRange: number[], outputRange: number[], easeFunc?: EasingCurve | ((t: number) => number)): number;
-}
-
-declare module '@mappedin/blue-dot/packages/common/math-utils' {
+     * The color of the heading cone.
+     * @default #2266ff
+     */
+    color: string;
     /**
-      * Clamp a number between lower and upper bounds with a warning
-      */
-    export function clampWithWarning(x: number, lower: number, upper: number, warning: string): number;
-}
-
-declare module '@mappedin/blue-dot/packages/common/array-utils' {
+     * The opacity of the heading cone.
+     * @default 0.7
+     */
+    opacity: number;
     /**
-      * Compare two arrays for equality
-      */
-    export function arraysEqual(arr1: any[] | null | undefined, arr2: any[] | null | undefined): boolean;
+     * Whether to display the heading cone when the BlueDot is inactive (timed out).
+     * @default false
+     */
+    displayWhenInactive: boolean;
+  };
+  /**
+   * The duration of the timeout in milliseconds.
+   * If the BlueDot does not receive a position update within this time, it will grey out until a position is received.
+   * @default 30000
+   */
+  timeout: number;
+  /**
+   * Whether to watch the device's position.
+   * @default true
+   */
+  watchDevicePosition: boolean;
+  /**
+   * Whether to log debug messages.
+   * @default false
+   */
+  debug: boolean;
+  /**
+   * The maximum acceptable accuracy in meters. Position updates with accuracy exceeding this value will be dropped.
+   * @default 50
+   */
+  accuracyThreshold: number;
+  /**
+   * The initial state of the BlueDot when enabled.
+   * @default 'hidden'
+   */
+  initialState: 'hidden' | 'inactive';
+  /**
+   * @hidden
+   * Whether the BlueDot must remain within the map bounds. Disabling this will disable analytics as well.
+   * @default true
+   */
+  preventOutOfBounds: boolean;
+};
+type BlueDotUpdateState = PartialDeep<BlueDotState>;
+/**
+ * Position update options for the {@link BlueDot.update} method.
+ */
+type BlueDotPositionUpdate = {
+  /**
+   * Latitude to override.
+   * Set to `'device'` to reset to the device's latitude.
+   */
+  latitude?: GeolocationPosition['coords']['latitude'] | 'device' | undefined;
+  /**
+   * Longitude to override.
+   * Set to `'device'` to reset to the device's longitude.
+   */
+  longitude?: GeolocationPosition['coords']['longitude'] | 'device' | undefined;
+  /**
+   * Accuracy to override.
+   * Set to `'device'` to reset to the device's accuracy.
+   * Set to `undefined` to disable the accuracy ring.
+   */
+  accuracy?: GeolocationPosition['coords']['accuracy'] | 'device' | undefined;
+  /**
+   * Heading to override.
+   * Set to `'device'` to reset to the device's heading.
+   * Set to `undefined` to disable the heading indicator.
+   */
+  heading?: GeolocationPosition['coords']['heading'] | 'device' | undefined;
+  /**
+   * Floor or floorId to override.
+   * Set to `'device'` to reset to the device's floor level.
+   * Set to `undefined` to disable floor level and show the BlueDot on all floors.
+   */
+  floorOrFloorId?: Floor | string | 'device' | undefined;
+  /**
+   * Timestamp of the position update in milliseconds.
+   */
+  timestamp?: number;
+};
+type BlueDotPositionUpdateWithFloor = Omit<BlueDotPositionUpdate, 'floorOrFloorId'> & {
+  floor?: Floor | 'device' | undefined;
+};
+type BlueDotPositionProcessor = (current: BlueDotPositionUpdateWithFloor, incoming: BlueDotPositionUpdateWithFloor) => BlueDotPositionUpdateWithFloor | undefined;
+/**
+ * Options for the BlueDot update method.
+ */
+type BlueDotUpdateOptions = {
+  /**
+   * If true, maintains the current state and skips timers and analytics for this update.
+   * @default false
+   */
+  silent?: boolean;
+  /**
+   * If true, animates the position change. If false, updates immediately.
+   * @default true
+   */
+  animate?: boolean;
+};
+type GeolocationPositionExtended = GeolocationPosition & {
+  coords: GeolocationPosition['coords'] & {
+    readonly floorLevel?: number;
+  };
+};
+//#endregion
+//#region src/blue-dot.d.ts
+/**
+ * Show a Blue Dot indicating the device's position on the map.
+ *
+ * @example
+ * ```ts
+ * import { show3dMap } from '@mappedin/mappedin-js';
+ * import { BlueDot } from '@mappedin/blue-dot';
+ *
+ * const mapView = await show3dMap(...);
+ *
+ * // Enable BlueDot
+ * const blueDot = new BlueDot(mapView).enable();
+ *
+ * // Option 1: Listen for position updates from the device
+ * blueDot.on('position-update', (position) => {
+ *   console.log('User position:', position);
+ * });
+ *
+ * // Option 2: Update position manually
+ * blueDot.update({ latitude, longitude, accuracy, floorOrFloorId });
+ *
+ * ```
+ */
+declare class BlueDot implements MapViewExtension<BlueDotState> {
+  #private;
+  /**
+   * Create a new {@link BlueDot} instance.
+   */
+  constructor(mapView: MapView);
+  /**
+   * Get the Model for the BlueDot core element.
+   */
+  get dotModel(): Model | undefined;
+  /**
+   * Get the Model for the accuracy ring.
+   */
+  get accuracyRingModel(): Model | undefined;
+  /**
+   * Get the Model for the heading cone.
+   */
+  get headingConeModel(): Model | undefined;
+  /**
+   * Whether the BlueDot is currently enabled.
+   */
+  get isEnabled(): boolean;
+  /**
+   * The current state of the BlueDot. Can be 'hidden', 'active', 'inactive', or 'disabled'.
+   * Listen for state changes using the 'status-change' event.
+   *
+   * @example
+   * mapView.BlueDot.on('status-change', ({ status }) => {
+   *   if (status === 'active') {
+   *     // BlueDot is visible and tracking
+   *   }
+   * });
+   */
+  get status(): BlueDotStatus;
+  /**
+   * Whether the BlueDot is currently following the user (camera follow mode).
+   */
+  get isFollowing(): boolean;
+  /**
+   * The direction the user is facing in degrees from north clockwise.
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/GeolocationCoordinates/heading
+   */
+  get heading(): GeolocationPosition['coords']['heading'] | undefined;
+  /**
+   * The accuracy of the current position in metres.
+   */
+  get accuracy(): GeolocationPosition['coords']['accuracy'] | undefined;
+  /**
+   * The coordinate of the current position.
+   */
+  get coordinate(): Coordinate | undefined;
+  /**
+   * Returns the current Blue Dot state.
+   */
+  getState(): ReadonlyDeep<BlueDotState>;
+  /**
+   * The floor the Blue Dot is currently on. If undefined, the Blue Dot will appear on every floor.
+   */
+  get floor(): Floor | undefined;
+  /**
+   * Enable the Blue Dot. It will be hidden until a position is received either from the browser or by calling {@link BlueDot.update}.
+   * @param options - The options to setup the Blue Dot (see {@link BlueDotUpdateState}).
+   *
+   * @example Enable with default options
+   * ```ts
+   * const blueDot = new BlueDot(mapView);
+   * blueDot.enable();
+   * ```
+   * @example Enable with custom color and accuracy ring
+   * ```ts
+   * const blueDot = new BlueDot(mapView);
+   * blueDot.enable({ color: '#00ff00', accuracyRing: { color: '#00ff00', opacity: 0.2 } });
+   * ```
+   *
+   * @see See the [BlueDot Guide](https://developer.mappedin.com/web-sdk/blue-dot) for more information.
+   */
+  enable: (options?: BlueDotUpdateState) => void;
+  /**
+   * Disable the Blue Dot. It will be hidden and no longer update.
+   */
+  disable: () => void;
+  /**
+   * Subscribe to a BlueDot event.
+   * @param eventName The name of the event to listen for.
+   * @param fn The function to call when the event is emitted.
+   */
+  on: PubSub<BlueDotEventPayloads>['on'];
+  /**
+   * Unsubscribe from a BlueDot event.
+   * @param eventName The name of the event to unsubscribe from.
+   * @param fn The function to unsubscribe from the event.
+   */
+  off: PubSub<BlueDotEventPayloads>['off'];
+  /**
+   * Update the BlueDot state after it has been enabled.
+   * This allows overriding previously set values like colors, and other options.
+   * @param options - The options to update
+   *
+   * @example Update color and accuracy ring
+   * ```ts
+   * const blueDot = new BlueDot(mapView);
+   * blueDot.updateState({
+   *   color: '#ff0000',
+   *   accuracyRing: { color: '#ff0000', opacity: 0.5 }
+   * });
+   * ```
+   */
+  updateState: (options: BlueDotUpdateState) => void;
+  /**
+   * Enable or disable the devices's geolocation listener to automatically position the Blue Dot.
+   * If enabled, the device will request permission to access the user's precise location.
+   *
+   * @remarks This will emit a 'position-update' event every time a new position is received.
+   *
+   * @param watch - Whether to enable or disable the listener.
+   */
+  watchDevicePosition: (watch: boolean) => void;
+  /**
+   * Enable or disable the device orientation listener to automatically update the Blue Dot's heading.
+   * This must be enabled in response to a user action such as a tap or click and cannot be enabled automatically.
+   *
+   * @remarks This will emit a 'device-orientation-update' event every time the device's orientation changes.
+   * Device orientation changes will not emit a 'position-update' event.
+   *
+   * @see https://www.w3.org/TR/orientation-event/#dom-deviceorientationevent-requestpermission
+   *
+   * @param watch - Whether to enable or disable the listener.
+   *
+   * @example Enable device orientation listener
+   * ```ts
+   * const blueDot = new BlueDot(mapView);
+   * // Enable device orientation on button click
+   * button.addEventListener('click', () => {
+   *   blueDot.watchDeviceOrientation(true);
+   * });
+   * ```
+   */
+  watchDeviceOrientation: (watch: boolean) => Promise<void>;
+  /**
+   * Manually override some position properties of the Blue Dot.
+   * Accepts a full GeolocationPosition object or a partial {@link BlueDotPositionUpdate} object.
+   *
+   * @remarks This will emit a 'position-update' event.
+   *
+   * @example Manually set the accuracy and heading
+   * ```ts
+   * api.BlueDot.update({ accuracy: 10, heading: 90 });
+   * ```
+   * @example Reset accuracy and heading to device values
+   * ```ts
+   * api.BlueDot.update({ accuracy: 'device', heading: 'device' });
+   * ```
+   */
+  update: (position: GeolocationPositionExtended | BlueDotPositionUpdate | undefined, options?: BlueDotUpdateOptions) => void;
+  /**
+   * Set the camera to follow the BlueDot in various modes. User interaction will cancel following automatically.
+   * @param mode The follow mode ('position-only', 'position-and-heading', 'position-and-path-direction', or false to disable).
+   * @param cameraOptions Optional camera options (zoom, pitch, etc.).
+   *
+   * @example
+   * mapView.BlueDot.follow('position-and-heading', { zoomLevel: 21, pitch: 45 });
+   */
+  follow: (mode: FollowMode, cameraOptions?: FollowCameraOptions) => void;
+  /**
+   * Set a position processor callback that allows intercepting and modifying device/geolocation position updates before they are applied.
+   *
+   * **Note**: This processor only applies to automatic position updates from device geolocation.
+   * Manual position updates via `update()` method bypass the processor and are applied directly.
+   *
+   * @param processor - A callback function that receives current state and incoming update. Return undefined to discard the update, or return a modified update object.
+   *
+   * @example Discard inaccurate positions
+   * ```ts
+   * blueDot.setPositionProcessor((current, incoming) => {
+   *   if (incoming.accuracy && incoming.accuracy > 50) {
+   *     return undefined; // Discard update
+   *   }
+   *   return incoming; // Accept update
+   * });
+   * ```
+   *
+   * @example Modify incoming positions
+   * ```ts
+   * blueDot.setPositionProcessor((current, incoming) => {
+   *   // Apply custom smoothing or validation logic
+   *   return {
+   *     ...incoming,
+   *     accuracy: Math.min(incoming.accuracy || 100, 10) // Cap accuracy
+   *   };
+   * });
+   * ```
+   */
+  setPositionProcessor(processor?: BlueDotPositionProcessor): void;
+  destroy: () => void;
+  private onPositionUpdate;
+  private onPositionError;
 }
-
+//#endregion
+export { BlueDot, type BlueDotAction, type BlueDotEventPayloads, type BlueDotEvents, type BlueDotPositionProcessor, type BlueDotPositionUpdate, type BlueDotPositionUpdateWithFloor, type BlueDotState, type BlueDotStatus, type BlueDotUpdateOptions, type FollowCameraOptions, type FollowMode, type GeolocationPositionExtended };