@mappedin/blue-dot 6.0.1-beta.54

package/lib/esm/index.d.ts

@@ -0,0 +1,706 @@
+// Generated by dts-bundle v0.7.3
+// Dependencies for this module:
+//   ../blue-dot/@packages/internal/common
+//   ../blue-dot/@mappedin/mappedin-js
+//   ../blue-dot/three
+//   ../blue-dot/zod
+//   ../blue-dot/type-fest
+
+declare module '@mappedin/blue-dot' {
+    export { BlueDot } from '@mappedin/blue-dot/blue-dot/src/blue-dot';
+    export type { BlueDotEvents, BlueDotEventPayloads, BlueDotPositionUpdate, BlueDotState, BlueDotAction, FollowMode, FollowCameraOptions, BlueDotOptions, } from '@mappedin/blue-dot/blue-dot/src/types';
+}
+
+declare module '@mappedin/blue-dot/blue-dot/src/blue-dot' {
+    import { PubSub } from '@packages/internal/common';
+    import type { MapView } from '@mappedin/mappedin-js';
+    import type { BlueDotEventPayloads, BlueDotOptions, BlueDotPositionUpdate, BlueDotState, FollowCameraOptions, FollowMode } from '@mappedin/blue-dot/blue-dot/src/types';
+    /**
+        * 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 {
+            #private;
+            /**
+                * Create a new {@link BlueDot} instance.
+                */
+            constructor(mapView: MapView);
+            /**
+                * The current state of the BlueDot. Can be 'hidden', 'active', 'inactive', or 'disabled'.
+                * Listen for state changes using the 'state-change' event.
+                *
+                * @example
+                * mapView.BlueDot.on('state-change', ({ state }) => {
+                *   if (state === 'active') {
+                *     // BlueDot is visible and tracking
+                *   }
+                * });
+                */
+            get state(): BlueDotState;
+            /**
+                * Whether the BlueDot is currently following the user (camera follow mode).
+                */
+            get following(): 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(): number | null | undefined;
+            /**
+                * The accuracy of the current position in metres.
+                */
+            get accuracy(): number | undefined;
+            /**
+                * The coordinate of the current position.
+                */
+            get coordinate(): import("@mappedin/mappedin-js").Coordinate | undefined;
+            /**
+                * The floor the Blue Dot is currently on. If undefined, the Blue Dot will appear on every floor.
+                */
+            get floor(): import("@mappedin/mappedin-js").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?: BlueDotOptions) => void;
+            /**
+                * Disable the Blue Dot. It will be hidden and no longer update.
+                */
+            disable: () => void;
+            on: PubSub<BlueDotEventPayloads>['on'];
+            off: PubSub<BlueDotEventPayloads>['off'];
+            /**
+                * 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: BlueDotPositionUpdate) => 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;
+            destroy: () => void;
+    }
+}
+
+declare module '@mappedin/blue-dot/blue-dot/src/types' {
+    import type { Coordinate, Floor } from '@mappedin/mappedin-js';
+    import type { EasingCurve } from '@mappedin/blue-dot/packages/common';
+    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 state changes.
+                */
+            'state-change': {
+                    /**
+                        * The new state of the Blue Dot.
+                        */
+                    state: BlueDotState;
+                    /**
+                        * The action that caused the state 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: undefined;
+    };
+    export type BlueDotEvents = keyof BlueDotEventPayloads;
+    export type BlueDotState = 'hidden' | 'active' | 'inactive' | 'disabled';
+    export type BlueDotAction = 'timeout' | 'error' | 'position-update' | 'enable' | 'disable';
+    export type BlueDotOptions = {
+            /**
+                * 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;
+            };
+            /**
+                * 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;
+    };
+    /**
+        * 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;
+    };
+}
+
+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';
+    export * from '@mappedin/blue-dot/packages/common/type-utils';
+}
+
+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;
+}
+
+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);
+    }
+}
+
+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 function clampWithWarning(x: number, lower: number, upper: number, warning: string): number;
+    export function arraysEqual(arr1: any[] | null | undefined, arr2: any[] | null | undefined): boolean;
+    export function isBrowser(): boolean;
+    export {};
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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
+                */
+            _subscribers: any;
+            /**
+                * @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;
+    }
+}
+
+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];
+    }
+}
+
+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;
+    /**
+        * 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;
+    /**
+        * 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;
+    /**
+        * 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;
+    /**
+        * 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];
+    /**
+        * 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' {
+    import { z } from 'zod';
+    export const easingCurveSchema: z.ZodEnum<["ease-in", "ease-out", "ease-in-out", "linear"]>;
+    export type EasingCurve = z.infer<typeof easingCurveSchema>;
+    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;
+    /**
+      * 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/type-utils' {
+    import type { SetOptional } from 'type-fest';
+    type Primitive = string | number | boolean | null | undefined;
+    export type PartialExcept<T, K extends string> = {
+            [P in keyof T as P extends K ? P : never]: T[P];
+    } & {
+            [P in keyof T as P extends K ? never : P]?: T[P] extends Primitive ? T[P] : T[P] extends (infer U)[] ? PartialExcept<U, K>[] : PartialExcept<T[P], K>;
+    };
+    /**
+        * Utility type that extracts nested values matching a specific type with recursion depth limit
+        * @example
+        * type A = ExtractDeep<{ a: { b: string; c: number; }; d: string; e: number; }, number>;
+        * // { a: { c: number; } e: number; }
+        */
+    export type ExtractDeep<T, U, Depth extends readonly number[] = []> = Depth['length'] extends 3 ? any : {
+            [K in keyof T as T[K] extends U ? K : T[K] extends object | undefined ? ExtractDeep<NonNullable<T[K]>, U, [...Depth, 0]> extends never ? never : K : never]: T[K] extends object | undefined ? undefined extends T[K] ? ExtractDeep<NonNullable<T[K]>, U, [...Depth, 0]> | undefined : ExtractDeep<NonNullable<T[K]>, U, [...Depth, 0]> : T[K] extends U ? T[K] : never;
+    };
+    /**
+        * Utility type that makes all properties of a type required, but allows undefined values
+        * to satisfy the required type.
+        * https://medium.com/terria/typescript-transforming-optional-properties-to-required-properties-that-may-be-undefined-7482cb4e1585
+        * @example
+        * type A = Complete<{ a: string; b: number; c: undefined; }>;
+        * // { a: string; b: number; c: undefined; }
+        */
+    export type Complete<T> = {
+            [P in keyof Required<T>]: Pick<T, P> extends Required<Pick<T, P>> ? T[P] : T[P] | undefined;
+    };
+    /**
+        * Utility type that makes all properties required except for the ones specified in the second argument.
+        * @example
+        * type A = RequiredExcept<{ a: string; b: number; c: undefined; }, 'c'>;
+        * // { a: string; b: number; c?: undefined; }
+        */
+    export type RequiredExcept<T, K extends keyof T> = SetOptional<Required<T>, K>;
+    export {};
+}
+