@wemap/providers 12.10.8 → 12.11.0

package/{src/ProvidersOptions.ts → dist/src/ProvidersOptions.d.ts}

@@ -1,31 +1,22 @@
-const ProvidersOptions = {
-
+declare const ProvidersOptions: {
     /**
      * Does provider will use map to
      */
-    useMapMatching: true,
-
+    useMapMatching: boolean;
     /**
      * Providers listed here will not be used by the system
      * List of {@link Provider#pname}
      */
-    ignoreProviders: [] as string[],
-
+    ignoreProviders: string[];
     /**
      * Some providers are not used by default (i.e. PoleStar) because they
      * require data from an optional external service or because they drain more
      * battery. They can be added to this list to be used
      * List of {@link Provider#pname}
      */
-    optionalProviders: [] as string[],
-
-    stopOnError: true,
-
-    checkAvailabilityOnStart: true,
-
-    get hasPoleStar() {
-        return this.optionalProviders.includes('PoleStar');
-    }
+    optionalProviders: string[];
+    stopOnError: boolean;
+    checkAvailabilityOnStart: boolean;
+    readonly hasPoleStar: boolean;
 };
-
 export default ProvidersOptions;

package/dist/src/errors/AskImuOnDesktopError.d.ts

@@ -0,0 +1,5 @@
+declare class AskImuOnDesktopError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default AskImuOnDesktopError;

package/dist/src/errors/ContainsIgnoredProviderError.d.ts

@@ -0,0 +1,5 @@
+declare class ContainsIgnoredProviderError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default ContainsIgnoredProviderError;

package/dist/src/errors/GeolocationApiMissingError.d.ts

@@ -0,0 +1,5 @@
+declare class GeolocationApiMissingError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default GeolocationApiMissingError;

package/dist/src/errors/GeolocationPermissionDeniedError.d.ts

@@ -0,0 +1,5 @@
+declare class GeolocationPermissionDeniedError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default GeolocationPermissionDeniedError;

package/dist/src/errors/GeolocationPositionUnavailableError.d.ts

@@ -0,0 +1,5 @@
+declare class GeolocationPositionUnavailableError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default GeolocationPositionUnavailableError;

package/dist/src/errors/IpResolveServerError.d.ts

@@ -0,0 +1,5 @@
+declare class IpResolveServerError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default IpResolveServerError;

package/dist/src/errors/MissingAccelerometerError.d.ts

@@ -0,0 +1,6 @@
+import { default as MissingSensorError } from './MissingSensorError.js';
+declare class MissingAccelerometerError extends MissingSensorError {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default MissingAccelerometerError;

package/dist/src/errors/MissingArCoreError.d.ts

@@ -0,0 +1,5 @@
+declare class MissingArCoreError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default MissingArCoreError;

package/dist/src/errors/MissingGyroscopeError.d.ts

@@ -0,0 +1,6 @@
+import { default as MissingSensorError } from './MissingSensorError.js';
+declare class MissingGyroscopeError extends MissingSensorError {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default MissingGyroscopeError;

package/dist/src/errors/MissingMagnetometerError.d.ts

@@ -0,0 +1,5 @@
+import { default as MissingSensorError } from './MissingSensorError.js';
+declare class MissingMagnetometerError extends MissingSensorError {
+    constructor(message?: string);
+}
+export default MissingMagnetometerError;

package/dist/src/errors/MissingNativeInterfaceError.d.ts

@@ -0,0 +1,5 @@
+declare class MissingNativeInterfaceError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default MissingNativeInterfaceError;

package/dist/src/errors/MissingPoleStarError.d.ts

@@ -0,0 +1,5 @@
+declare class MissingPoleStarError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default MissingPoleStarError;

package/dist/src/errors/MissingSensorError.d.ts

@@ -0,0 +1,6 @@
+declare class MissingSensorError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+    from(fromMessage: string): this;
+}
+export default MissingSensorError;

package/dist/src/errors/NoProviderFoundError.d.ts

@@ -0,0 +1,5 @@
+declare class NoProviderFoundError extends Error {
+    static DEFAULT_MESSAGE: string;
+    constructor(message?: string);
+}
+export default NoProviderFoundError;

package/dist/src/events/AvailabilityHelper.d.ts

@@ -0,0 +1,5 @@
+export type AvailabilityPromise = Promise<Error | null | void>;
+export default class AvailabilityHelper {
+    static every(availabilityPromises: AvailabilityPromise[]): AvailabilityPromise;
+    static some(availabilityPromises: AvailabilityPromise[]): AvailabilityPromise;
+}

package/dist/src/events/ProvidersLoggerOld.d.ts

@@ -0,0 +1,24 @@
+interface MyObject {
+    getName(): string;
+}
+declare class ProvidersLoggerOld {
+    _enabled: boolean;
+    currentId: number;
+    objectsIdMap: WeakMap<MyObject, number>;
+    pushEvents: {
+        [key: number]: number;
+    };
+    pushEventsRef: {
+        [key: number]: MyObject;
+    };
+    interval?: number;
+    initDate?: number;
+    get enabled(): boolean;
+    set enabled(_newVal: boolean);
+    initializeInterval(): void;
+    getObjectId(object: MyObject): number;
+    addEvent(object: MyObject, method: string): void;
+    incrementNotifications(object: MyObject): void;
+}
+declare const _default: ProvidersLoggerOld;
+export default _default;

package/dist/src/events/Types.d.ts

@@ -0,0 +1,34 @@
+import { Attitude, UserPosition } from '@wemap/geo';
+import { Vector16_t, Vector3_t } from '@wemap/maths';
+export type Acceleration = Readonly<{
+    readonly timestamp: number;
+    readonly values: Vector3_t;
+}>;
+export type AngularRate = Readonly<{
+    readonly timestamp: number;
+    readonly values: Vector3_t;
+}>;
+export type HighRotation = Readonly<{
+    readonly timestamp: number;
+}>;
+export type MagnetometerNeedCalibration = Readonly<{
+    readonly angle: number;
+}>;
+export declare class RelativeAttitude extends Attitude {
+}
+export declare class AbsoluteAttitude extends Attitude {
+}
+export declare class AbsolutePosition extends UserPosition {
+}
+export type Inclination = number;
+export type Barcode = string;
+export type Step = {
+    readonly size: number;
+    readonly number: number;
+};
+export type Turn = {
+    readonly timestamp: number;
+};
+export type StraightLine = boolean;
+export type CameraProjectionMatrix = Vector16_t;
+export type CameraNativeState = 'started' | 'stopped';

package/dist/src/mapmatching/MapMatchingHandler.d.ts

@@ -0,0 +1,93 @@
+import { UserPosition, Coordinates } from '@wemap/geo';
+import { Graph, GraphProjection, Itinerary, ItineraryInfoManager, Vertex } from '@wemap/routers';
+import { default as Provider } from '../providers/Provider.js';
+import { AbsolutePosition } from '../events/Types.js';
+type MapMatchingEvent = {
+    graph?: Graph;
+    itinerary?: Itinerary | null;
+};
+declare class MapMatchingHandler extends Provider<MapMatchingEvent> {
+    static DEFAULT_MM_MAX_ANGLE: number;
+    static DEFAULT_MM_MAX_DIST: number;
+    static DEFAULT_MM_MIN_DIST: number;
+    static DEFAULT_USE_ITINERARY_START_AS_POSITION: boolean;
+    static DEFAULT_USE_ORIENTATION_MATCHING: boolean;
+    static DEFAULT_MM_HUGE_JUMP_DISTANCE: number;
+    static DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE: number;
+    static DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING: number;
+    static DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING: number;
+    static DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE: number;
+    static DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD: number;
+    _mapMatchingMaxDistance: number;
+    _mapMatchingMinDistance: number;
+    _mapMatchingMaxAngleBearing: number;
+    _useItineraryStartAsPosition: boolean;
+    _useOrientationMatching: boolean;
+    _hugeJumpDistance: number;
+    _disableMMCloseToATurnDistance: number;
+    _minStepsBetweenOrientationMatching: number;
+    _minStepsForOrientationMatching: number;
+    _lastProjectionsWindowSize: number;
+    _lastProjectionsEdgeAngleThreshold: number;
+    _graph: Graph | null;
+    _internalProvidersStarted: boolean;
+    _straightLineProviderId?: number;
+    _turnProviderId?: number;
+    _stepProviderId?: number;
+    _projectionsWithAbsAndWithoutRelAttitudeInARow: GraphProjection[];
+    _countStepsFromLastMatching: number;
+    _lastProjections: GraphProjection[];
+    _itineraryInfoManager: ItineraryInfoManager | null;
+    getName: () => string;
+    availability: () => Promise<void>;
+    start(): void;
+    stop(): void;
+    _manageStartStop: () => void;
+    _startInternalProviders(): void;
+    _stopInternalProviders(): void;
+    get enabled(): boolean;
+    get graph(): Graph | null;
+    set graph(graph: Graph | null);
+    set itinerary(itinerary: Itinerary | null);
+    canUseMapMatching(): false | Graph | null;
+    private _notifyPositionFromItineraryInput;
+    notifyPositionFromFeed(newPositionEvent: AbsolutePosition): void;
+    /**
+     * @returns if input position is used by the system (true = used, false = discarded)
+     */
+    notifyPositionFromAbsolute(newPosition: AbsolutePosition): boolean;
+    /**
+     * @returns if input position is used by the system (true = used, false = discarded)
+     */
+    notifyPositionFromRelative(newPosition: AbsolutePosition): boolean;
+    _detectWrongBigJump(projection: GraphProjection<UserPosition>): boolean;
+    _areLastProjectionsInTheSameDirection(): boolean;
+    _nodeHasTurn(vertex: Vertex): boolean | undefined;
+    _hasTurnInCircle(center: Coordinates, radius: number): boolean;
+    tryOrientationMatching(projection: GraphProjection<UserPosition>): void;
+    getProjection(position: UserPosition, useDistance?: boolean, useBearing?: boolean): GraphProjection<UserPosition> | null | undefined;
+    get maxDistance(): number;
+    set maxDistance(maxDistance: number);
+    get minDistance(): number;
+    set minDistance(minDistance: number);
+    get maxAngleBearing(): number;
+    set maxAngleBearing(maxAngleBearing: number);
+    get useItineraryStartAsPosition(): boolean;
+    set useItineraryStartAsPosition(useItineraryStartAsPosition: boolean);
+    get useOrientationMatching(): boolean;
+    set useOrientationMatching(useOrientationMatching: boolean);
+    get hugeJumpDistance(): number;
+    set hugeJumpDistance(hugeJumpDistance: number);
+    get disableMMCloseToATurnDistance(): number;
+    set disableMMCloseToATurnDistance(disableMMCloseToATurnDistance: number);
+    get minStepsBetweenOrientationMatching(): number;
+    set minStepsBetweenOrientationMatching(minStepsBetweenOrientationMatching: number);
+    get minStepsForOrientationMatching(): number;
+    set minStepsForOrientationMatching(minStepsForOrientationMatching: number);
+    get lastProjectionsWindowSize(): number;
+    set lastProjectionsWindowSize(lastProjectionsWindowSize: number);
+    get lastProjectionsEdgeAngleThreshold(): number;
+    set lastProjectionsEdgeAngleThreshold(lastProjectionsEdgeAngleThreshold: number);
+}
+declare const _default: MapMatchingHandler;
+export default _default;

package/dist/src/providers/Constants.d.ts

@@ -0,0 +1,4 @@
+declare const Constants: {
+    DEFAULT_ALTITUDE: number;
+};
+export default Constants;

package/{src/providers/NativeProviders.ts → dist/src/providers/NativeProviders.d.ts}

@@ -1,12 +1,7 @@
-//-----------------
-// Native Interface
-//-----------------
-
 export interface NativeInterface {
-    getArCoreProvider: () => NativeArCore,
-    getPoleStarProvider: () => NativePoleStar
+    getArCoreProvider: () => NativeArCore;
+    getPoleStarProvider: () => NativePoleStar;
 }
-
 export interface NativeArCore {
     checkAvailability(): boolean;
     start(): void;
@@ -15,23 +10,15 @@ export interface NativeArCore {
     enableBarcodeScanner(): void;
     disableBarcodeScanner(): void;
 }
-
 export interface NativePoleStar {
     checkAvailability(): boolean;
     start(): void;
     stop(): void;
     setApiKey(key: string): void;
 }
-
-
-//--------------------------
-// Native Callback Interface
-//--------------------------
-
 export interface NativeCallbackInterface {
     polestar?: NativeCallbackPoleStar;
 }
-
 export interface NativePolestarPosition {
     lat: number;
     lng: number;
@@ -40,15 +27,7 @@ export interface NativePolestarPosition {
     accuracy: number;
     bearing: number;
 }
-
 export interface NativeCallbackPoleStar {
     callbackError(errorMessage: string): void;
     callbackPosition(jsonString: string): void;
 }
-
-// declare global {
-//     interface Window {
-//         __nativeProviders?: NativeInterface;
-//         __nativeJsProviders?: NativeCallbackInterface;
-//     }
-// }

package/dist/src/providers/Provider.d.ts

@@ -0,0 +1,64 @@
+import { ProviderState } from './ProviderState.js';
+import { AvailabilityPromise } from '../events/AvailabilityHelper.js';
+import { NativeCallbackInterface, NativeInterface } from './NativeProviders.js';
+declare global {
+    interface Window {
+        __nativeProviders?: NativeInterface;
+        __nativeJsProviders?: NativeCallbackInterface;
+    }
+}
+/**
+ * A provider is a meta class to define an entity which can be
+ * started / stopped and provides a data of <E>
+ */
+declare abstract class Provider<E> {
+    static _callbackUniqueId: number;
+    static _uniqueId: number;
+    id: number;
+    state: ProviderState;
+    _lastEvent: E | null;
+    _eventsCallbacks: {
+        id: number;
+        onEvent: ((event: E) => void) | null;
+        onError: ((error: Error) => void) | null;
+        optional: boolean;
+    }[];
+    _monitoringCallbacks: {
+        id: number;
+        onStarted: (() => void) | null;
+        onStopped: (() => void) | null;
+    }[];
+    /**
+     * Provider constructor
+     */
+    constructor();
+    /**
+     * Get the provider name
+     */
+    abstract getName(): string;
+    /**
+     * Resolve with an error if the provider is not available
+     */
+    getAvailability(): AvailabilityPromise;
+    protected abstract availability(): AvailabilityPromise;
+    protected get hasNativeInterface(): boolean;
+    protected get nativeInterface(): NativeInterface | null;
+    protected get nativeJsInterface(): NativeCallbackInterface | null;
+    get useCameraNatively(): boolean;
+    addEventListener(onEvent?: ((events: E) => void) | null, onError?: ((error: Error) => void) | null, startIfNecessary?: boolean): number;
+    removeEventListener(callbackUniqueId?: number): void;
+    addMonitoringListener(onStarted?: (() => void) | null, onStopped?: (() => void) | null): number;
+    removeMonitoringListener(callbackUniqueId?: number): void;
+    protected abstract start(): void;
+    protected abstract stop(): void;
+    /**
+     * Notify the subscriber defined in {@link addEventListener}
+     */
+    notify: (event: E) => void;
+    /**
+     * Notify the subscriber defined in {@link addEventListener}
+     */
+    notifyError: (error: Error) => void;
+    get lastEvent(): E | null;
+}
+export default Provider;

package/dist/src/providers/attitude/EkfAttitude.d.ts

@@ -0,0 +1,41 @@
+import { Matrix3_t, Matrix4_t, Quaternion_t, Vector3_t, Vector4_t } from '@wemap/maths';
+type RelativeNoises = {
+    acc: number;
+    gyr: number;
+};
+type AbsoluteNoises = {
+    acc: number;
+    gyr: number;
+    yc: number;
+};
+type RelativeNoisesMat = {
+    acc: Matrix3_t;
+    gyr: Matrix3_t;
+};
+type AbsoluteNoisesMat = {
+    acc: Matrix3_t;
+    gyr: Matrix3_t;
+    yc: Matrix3_t;
+};
+declare class EkfAttitude {
+    P: Matrix4_t;
+    accRef: Vector3_t;
+    cRef: Vector3_t;
+    noises: {
+        relative: RelativeNoisesMat;
+        absolute: AbsoluteNoisesMat;
+    };
+    quaternion: Quaternion_t | null;
+    constructor(accRef?: Vector3_t, ycRef?: Vector3_t);
+    setRelativeNoises(relativeNoises: RelativeNoises): void;
+    setAbsoluteNoises(absoluteNoises: AbsoluteNoises): void;
+    /**
+     * Try to initialize filter.
+     * To initialize, we need at least current acceleration (acc)
+     */
+    tryInitialize(acc: Vector3_t, mag?: Vector3_t): Quaternion_t;
+    update(diffTime: number, acc: Vector3_t, gyr: Vector3_t, mag?: Vector3_t): Quaternion_t;
+    computeC(b: Vector4_t): Matrix4_t;
+    jacobianES(q: Quaternion_t, v: Vector3_t): number[][];
+}
+export default EkfAttitude;

package/dist/src/providers/attitude/TurnProvider.d.ts

@@ -0,0 +1,17 @@
+import { default as Provider } from '../Provider.js';
+import { Turn } from '../../events/Types.js';
+declare class TurnProvider extends Provider<Turn> {
+    static SLIDING_WINDOW_TIME: number;
+    static STD_THRESHOLD: number;
+    static CONSIDER_TURN_UNTIL: number;
+    providerId?: number;
+    slidingWindow: [number, number][];
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    isTurning(): boolean;
+    private _parseRelativeAttitude;
+}
+declare const _default: TurnProvider;
+export default _default;

package/dist/src/providers/attitude/absolute/AbsoluteAttitudeFromBrowserProvider.d.ts

@@ -0,0 +1,60 @@
+import { Quaternion_t } from '@wemap/maths';
+import { default as Provider } from '../../Provider.js';
+import { default as AskImuOnDesktopError } from '../../../errors/AskImuOnDesktopError.js';
+import { AbsoluteAttitude, AbsolutePosition } from '../../../events/Types.js';
+export interface DeviceOrientationEventiOS extends DeviceOrientationEvent {
+    webkitCompassHeading: number | null;
+    webkitCompassAccuracy: number | null;
+    requestPermission?: () => Promise<'granted' | 'denied'>;
+}
+declare global {
+    interface Window {
+        addEventListener(evtName: 'deviceorientationabsolute', cb: (evt: DeviceOrientationEvent) => void, options?: boolean): void;
+        addEventListener(evtName: 'deviceorientation', cb: (evt: DeviceOrientationEventiOS) => void, options?: boolean): void;
+        removeEventListener(evtName: 'deviceorientationabsolute', cb: (evt: DeviceOrientationEvent) => void, options?: boolean): void;
+        removeEventListener(evtName: 'deviceorientation', cb: (evt: DeviceOrientationEventiOS) => void, options?: boolean): void;
+    }
+}
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame using
+ *  browser deviceorientation or deviceorientationabsolute
+ * The provider does not work until an AbsolutePosition is given. This is necessary to
+ *  calculate declination.
+ *
+ * -----------------------------------
+ * Overview of compatibilities:
+ * -----------------------------------
+ *
+ * Chrome Android (v72.0.3626): YES (via deviceorientationabsolute)
+ * Safari iOS (v12.0): YES (via deviceorientation and event.webkitCompassHeading)
+ * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
+ * Firefox Android (v65.0.1): NO {@link https://www.fxsitecompat.com/en-CA/docs/2018/various-device-sensor-apis-are-now-deprecated/}
+ *
+ * -----------------------------------
+ */
+declare class AbsoluteAttitudeFromBrowser extends Provider<AbsoluteAttitude> {
+    DEFAULT_ACCURACY: number;
+    absolutePositionProviderId?: number;
+    absolutePositionEvent?: AbsolutePosition;
+    declinationQuaternion?: Quaternion_t;
+    magQuaternion?: Quaternion_t;
+    magQuaternionTimestamp?: number;
+    iosPreviousQuat?: Quaternion_t;
+    iosIsSkyMode: boolean | null;
+    getName: () => string;
+    availability(): Promise<void> | Promise<AskImuOnDesktopError>;
+    start(): void;
+    stop(): void;
+    onDeviceOrientationChromeEvent: (e: DeviceOrientationEvent) => void;
+    onDeviceOrientationSafariEvent: (e: DeviceOrientationEventiOS) => void;
+    compute(): void;
+    /**
+     * Initialized declination quaternion using current position.
+     * This method should be theoretically called every time the user moves.
+     * But in reality declination does not change as much.
+     */
+    onAbsolutePositionEvent: (position: AbsolutePosition) => void;
+    static webkitCompassToHeading(_webkitCompassHeading: number, _beta: number, _gamma: number): number;
+}
+declare const _default: AbsoluteAttitudeFromBrowser;
+export default _default;

package/dist/src/providers/attitude/absolute/AbsoluteAttitudeProvider.d.ts

@@ -0,0 +1,44 @@
+import { AbsoluteHeading } from '@wemap/geo';
+import { Quaternion_t } from '@wemap/maths';
+import { default as Provider } from '../../Provider.js';
+import { AbsoluteAttitude, RelativeAttitude } from '../../../events/Types.js';
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
+ */
+declare class AbsoluteAttitudeProvider extends Provider<AbsoluteAttitude> {
+    static REL_ABS_DIVERGENCE_ANGLE_THRESHOLD: number;
+    static REL_ABS_DIVERGENCE_TIME_THRESHOLD: number;
+    static REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD: number;
+    private _absAttitudeFromBrowser?;
+    private _vpsProviderId?;
+    fromBrowserProviderId?: number;
+    highRotationProviderId?: number;
+    inclinationProviderId?: number;
+    relativeAttitudeProviderId?: number;
+    _attitudeFromBrowserErrored: boolean;
+    _attitudeFromRelativeErrored: boolean;
+    _relativeAttitude: RelativeAttitude | null;
+    _relativeAccuracy: number;
+    _lastForcedHeadingEvent?: AbsoluteAttitude | AbsoluteHeading;
+    _relAbsQuat?: Quaternion_t;
+    _wasHighRotationInProgress: boolean;
+    _timeFirstDivergence: number | null;
+    _callbackMagCalibration?: (data: {
+        angle: number;
+    }) => void;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    _setCallbackMagCalibration(cb: (data: {
+        angle: number;
+    }) => void): void;
+    private _onError;
+    _forceHeadingForRelative: (absoluteHeadingEvent: AbsoluteAttitude | AbsoluteHeading) => void;
+    _onRelativeAttitudeEvent: (event: RelativeAttitude) => void;
+    _onAttitudeFromBrowser: (event: AbsoluteAttitude) => void;
+    _onAttitudeFromVps: (event: AbsoluteAttitude) => void;
+    feed(data: AbsoluteHeading | AbsoluteAttitude): void;
+}
+declare const _default: AbsoluteAttitudeProvider;
+export default _default;

package/dist/src/providers/attitude/relative/RelativeAttitudeFromBrowserProvider.d.ts

@@ -0,0 +1,31 @@
+import { default as Provider } from '../../Provider.js';
+import { default as AskImuOnDesktopError } from '../../../errors/AskImuOnDesktopError.js';
+import { RelativeAttitude } from '../../../events/Types.js';
+/**
+ * Relative attitude provider gives the device attitude in a custom frame (x-right, y-front, z-up) using
+ *  browser deviceorientation
+ *
+ * -----------------------------------
+ * Overview of compatibilities:
+ * -----------------------------------
+ *
+ * Chrome Android (v72.0.3626): YES (via deviceorientation but deviceorientation.alpha is unreliable! Sometimes it starts at 0°, sometimes at 270°)
+ * Safari iOS (v12.0): YES (via deviceorientation)
+ * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
+ * Firefox Android (v65.0.1): YES (via deviceorientation)
+ *
+ * -----------------------------------
+ */
+declare class RelativeAttitudeFromBrowser extends Provider<RelativeAttitude> {
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    static DEFAULT_DRIFT: number;
+    getName: () => string;
+    availability(): Promise<void> | Promise<AskImuOnDesktopError>;
+    start(): void;
+    stop(): void;
+    onDeviceOrientationEvent: (e: DeviceOrientationEvent) => void;
+}
+declare const _default: RelativeAttitudeFromBrowser;
+export default _default;

package/dist/src/providers/attitude/relative/RelativeAttitudeFromEkfProvider.d.ts

@@ -0,0 +1,26 @@
+import { default as Provider } from '../../Provider.js';
+import { default as EkfAttitude } from '../EkfAttitude.js';
+import { AngularRate, RelativeAttitude } from '../../../events/Types.js';
+/**
+ * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using
+ *  browser deviceorientation
+ * The provider does not work until an offset is given.
+ */
+declare class RelativeAttitudeFromEkf extends Provider<RelativeAttitude> {
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    static DEFAULT_DRIFT: number;
+    accelerometerProviderId?: number;
+    ekfAttitude: EkfAttitude;
+    gyroscopeEvent?: AngularRate;
+    gyroscopeProviderId?: number;
+    lastTimestamp: number;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    private onAccelerometerEvent;
+}
+declare const _default: RelativeAttitudeFromEkf;
+export default _default;