@wemap/providers 12.10.8 → 12.10.9

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

@@ -0,0 +1,18 @@
+import { default as Provider } from '../../Provider.js';
+import { RelativeAttitude } from '../../../events/Types.js';
+declare class RelativeAttitudeFromInertial extends Provider<RelativeAttitude> {
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    static DEFAULT_DRIFT: number;
+    _highRotationsProviderId?: number;
+    listenerId?: number;
+    provider?: Provider<RelativeAttitude>;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    _parseEvent(event: RelativeAttitude): void;
+    stop(): void;
+}
+declare const _default: RelativeAttitudeFromInertial;
+export default _default;

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

@@ -0,0 +1,25 @@
+import { default as Provider } from '../../Provider.js';
+import { 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 RelativeAttitudeProvider extends Provider<RelativeAttitude> {
+    arCoreMonitoringId?: number;
+    arCoreProviderId?: number;
+    inertialProviderId?: number;
+    getName: () => string;
+    availability: () => import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    /**
+     * @override
+     */
+    stop(): void;
+    listenInertial: () => void;
+    unlistenInertial: () => void;
+    listenArCore: () => void;
+    unlistenArCore: () => void;
+}
+declare const _default: RelativeAttitudeProvider;
+export default _default;

package/dist/src/providers/imu/AccelerometerProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Provider } from '../Provider.js';
+import { Acceleration } from '../../events/Types.js';
+declare class AccelerometerProvider extends Provider<Acceleration> {
+    private imuProviderId?;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+}
+declare const _default: AccelerometerProvider;
+export default _default;

package/dist/src/providers/imu/GyroscopeProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Provider } from '../Provider.js';
+import { AngularRate } from '../../events/Types.js';
+declare class GyroscopeProvider extends Provider<AngularRate> {
+    private imuProviderId?;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+}
+declare const _default: GyroscopeProvider;
+export default _default;

package/dist/src/providers/imu/HighRotationsProvider.d.ts

@@ -0,0 +1,15 @@
+import { default as Provider } from '../Provider.js';
+import { HighRotation } from '../../events/Types.js';
+declare class HighRotationsProvider extends Provider<HighRotation> {
+    static THRESHOLD: number;
+    static DELAY_CONSIDERATION: number;
+    gyroscopeProviderId?: number;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    isInProgress(): boolean;
+    private _parseGyroscopeEvent;
+}
+declare const _default: HighRotationsProvider;
+export default _default;

package/dist/src/providers/imu/ImuProvider.d.ts

@@ -0,0 +1,34 @@
+import { default as Provider } from '../Provider.js';
+import { default as AskImuOnDesktopError } from '../../errors/AskImuOnDesktopError.js';
+import { Acceleration, AngularRate } from '../../events/Types.js';
+/**
+ * Imu (Inertial Measurement Unit) provider retrieve acceleration data
+ *  and/or angular rate data from inertial sensors.
+ *
+ * -----------------------------------
+ * Overview of compatibilities:
+ * -----------------------------------
+ *
+ * Chrome Android (v72.0.3626): YES (via devicemotion)
+ * Safari iOS (v12.0): YES (via devicemotion)
+ * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent}
+ * Firefox Android (v65.0.1): YES (via devicemotion)
+ *
+ * -----------------------------------
+ */
+type ImuEvent = {
+    readonly acceleration?: Acceleration;
+    readonly angularRate?: AngularRate;
+};
+declare class ImuProvider extends Provider<ImuEvent> {
+    getName: () => string;
+    availability(): Promise<void> | Promise<AskImuOnDesktopError>;
+    start(): void;
+    stop(): void;
+    /**
+     * devicemotion callback
+     */
+    private parseDeviceMotionEvent;
+}
+declare const _default: ImuProvider;
+export default _default;

package/dist/src/providers/imu/MagnetometerCalibrationProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Provider } from '../Provider.js';
+import { MagnetometerNeedCalibration } from '../../events/Types.js';
+declare class MagnetometerCalibrationProvider extends Provider<MagnetometerNeedCalibration> {
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    constructor();
+    start(): void;
+    stop(): void;
+}
+declare const _default: MagnetometerCalibrationProvider;
+export default _default;

package/dist/src/providers/inclination/InclinationFromAccProvider.d.ts

@@ -0,0 +1,18 @@
+import { default as Provider } from '../Provider.js';
+import { Inclination } from '../../events/Types.js';
+/**
+ * Inclination provider gives the inclination of the device using Imu Sensor
+ * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
+ *              when the device is layed on a table, inclination = 0
+ * This provider use window.orientation to return a result in function of screen orientation
+ */
+declare class InclinationFromAccProvider extends Provider<Inclination> {
+    providerId?: number;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    private onAccelerometerEvent;
+}
+declare const _default: InclinationFromAccProvider;
+export default _default;

package/dist/src/providers/inclination/InclinationFromRelativeAttitudeProvider.d.ts

@@ -0,0 +1,19 @@
+import { Quaternion_t } from '@wemap/maths';
+import { default as Provider } from '../Provider.js';
+import { Inclination } from '../../events/Types.js';
+/**
+ * Inclination provider gives the inclination of the device using Relative Attitude
+ * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
+ *              when the device is layed on a table, inclination = 0
+ * This provider use window.orientation to return a result in function of screen orientation
+ */
+declare class InclinationFromRelativeAttitudeProvider extends Provider<Inclination> {
+    providerId?: number;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    enuQuatToInclination(q: Quaternion_t): number;
+}
+declare const _default: InclinationFromRelativeAttitudeProvider;
+export default _default;

package/dist/src/providers/inclination/InclinationProvider.d.ts

@@ -0,0 +1,18 @@
+import { default as Provider } from '../Provider.js';
+import { Inclination } from '../../events/Types.js';
+/**
+ * Inclination provider gives the inclination of the device using Imu Sensor
+ * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
+ *              when the device is layed on a table, inclination = 0
+ * This provider use window.orientation to return a result in function of screen orientation
+ */
+declare class InclinationProvider extends Provider<Inclination> {
+    provider?: Provider<Inclination>;
+    providerId?: number;
+    getName: () => string;
+    availability(): import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): Promise<void>;
+    stop(): void;
+}
+declare const _default: InclinationProvider;
+export default _default;

package/dist/src/providers/legacy/helpers/HeadingUnlocker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HeadingUnlocker is designed to block Pdr Step Detection until user is aiming in the right direction
+ */
+declare class HeadingUnlocker {
+    static LO_ANGLE: number;
+    locked: boolean;
+    waitingOrientation: number | null;
+    unlock(): void;
+    lock(waitingOrientation: number): void;
+    feedHeading(heading: number): boolean;
+}
+export default HeadingUnlocker;

package/dist/src/providers/legacy/helpers/ThugDetector.d.ts

@@ -0,0 +1,8 @@
+import { Vector3_t } from '@wemap/maths';
+declare class ThugDetector {
+    static MIN_TIME_BETWEEN_DETECTIONS: number;
+    static EXT_ACC_NORM_THRESHOLD: number;
+    lastDetectionTimestamp: number;
+    compute(timestamp: number, acceleration: Vector3_t): boolean;
+}
+export default ThugDetector;

package/dist/src/providers/others/CameraNativeProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Provider } from '../Provider.js';
+import { CameraNativeState } from '../../events/Types.js';
+declare class CameraNativeProvider extends Provider<CameraNativeState> {
+    providerId?: number;
+    getName: () => string;
+    availability: () => Promise<void>;
+    start(): void;
+    stop(): void;
+}
+declare const _default: CameraNativeProvider;
+export default _default;

package/dist/src/providers/others/CameraProjectionMatrixProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Provider } from '../Provider.js';
+import { CameraProjectionMatrix } from '../../events/Types.js';
+declare class CameraProjectionMatrixProvider extends Provider<CameraProjectionMatrix> {
+    providerId?: number;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+}
+declare const _default: CameraProjectionMatrixProvider;
+export default _default;

package/dist/src/providers/position/absolute/AbsolutePositionProvider.d.ts

@@ -0,0 +1,35 @@
+import { GeoRelativePosition } from '@wemap/geo';
+import { default as Provider } from '../../Provider.js';
+import { AbsolutePosition } from '../../../events/Types.js';
+declare class AbsolutePositionProvider extends Provider<AbsolutePosition> {
+    static ACCURACY_RELOC_RATIO: number;
+    static USE_MM_FOR_FEED: boolean;
+    _polestarProviderId?: number;
+    _vpsProviderId?: number;
+    _gnssWifiProviderId?: number;
+    _relativePositionProviderId?: number;
+    _mapMatchingHandlerId?: number;
+    useAllAbsolutePositions: boolean;
+    _waitUntilNextVpsPosition: boolean;
+    _lastPolestarFix: number | null;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    /**
+     * @override
+     */
+    stop(): void;
+    private _shouldTakeIntoAccountNewAbsolutePosition;
+    /**
+     * @returns if input position is used by the system (true = used, false = discarded)
+     */
+    private _onAbsolutePosition;
+    /**
+     * @returns if input position is used by the system (true = used, false = discarded)
+     */
+    _onRelativePosition(relativeEvent: GeoRelativePosition): boolean;
+    feed(data: AbsolutePosition): void;
+    getBestPositionEvent(...absolutePositionEvents: (AbsolutePosition | null)[]): AbsolutePosition | null;
+}
+declare const _default: AbsolutePositionProvider;
+export default _default;

package/dist/src/providers/position/absolute/GnssWifiProvider.d.ts

@@ -0,0 +1,28 @@
+import { default as GeolocationApiMissingError } from '../../../errors/GeolocationApiMissingError.js';
+import { default as Provider } from '../../Provider.js';
+import { AbsolutePosition } from '../../../events/Types.js';
+/**
+ * GnssWifiProvider is a provider based on navigator.geolocation.
+ * This API does not allow us to know if the position returned is provided
+ *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
+ *  "GnssWifi".
+ */
+declare class GnssWifiProvider extends Provider<AbsolutePosition> {
+    static DEFAULT_DISCARD_POSITIONS_ABOVE: number;
+    discardPositionsAbove: number;
+    enableHighAccuracy: boolean;
+    geoLocationId?: number;
+    getName: () => string;
+    get positionOptions(): {
+        enableHighAccuracy: boolean;
+        timeout: number;
+        maximumAge: number;
+    };
+    availability(): Promise<void> | Promise<GeolocationApiMissingError>;
+    start(): void;
+    stop(): void;
+    private onNewPosition;
+    onPositionError: (error: GeolocationPositionError) => void;
+}
+declare const _default: GnssWifiProvider;
+export default _default;

package/dist/src/providers/position/absolute/IpProvider.d.ts

@@ -0,0 +1,16 @@
+import { default as Provider } from '../../Provider.js';
+import { AbsolutePosition } from '../../../events/Types.js';
+/**
+ * GnssWifiProvider is a provider based on navigator.geolocation.
+ * This API does not allow us to know if the position returned is provided
+ *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
+ *  "GnssWifi".
+ */
+declare class IpProvider extends Provider<AbsolutePosition> {
+    getName: () => string;
+    availability: () => Promise<void>;
+    start(): Promise<void>;
+    stop(): void;
+}
+declare const _default: IpProvider;
+export default _default;

package/dist/src/providers/position/absolute/PoleStarProvider.d.ts

@@ -0,0 +1,14 @@
+import { default as Provider } from '../../Provider.js';
+import { AbsolutePosition } from '../../../events/Types.js';
+declare class PoleStarProvider extends Provider<AbsolutePosition> {
+    getName: () => string;
+    constructor();
+    availability(): Promise<void> | Promise<Error>;
+    setApiKey(apiKey: string): void;
+    start(): void;
+    stop(): void;
+    get nativeProvider(): import('../../NativeProviders.js').NativePoleStar;
+    addMethodsToNativeJsProvider(): void;
+}
+declare const _default: PoleStarProvider;
+export default _default;

package/dist/src/providers/position/relative/GeoRelativePositionFromArCoreProvider.d.ts

@@ -0,0 +1,17 @@
+import { GeoRelativePosition, RelativePosition } from '@wemap/geo';
+import { default as Provider } from '../../Provider.js';
+import { ArCoreEvent } from '../../vision/ArCoreProvider.js';
+import { AbsoluteAttitude, RelativeAttitude } from '../../../events/Types.js';
+declare class GeoRelativePositionFromArCoreProvider extends Provider<GeoRelativePosition> {
+    absoluteAttitudeProviderId?: number;
+    arCoreProviderId?: number;
+    absoluteAttitudeEvent?: AbsoluteAttitude;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    onArCoreEvents: (event: ArCoreEvent) => void;
+    compute(relativePosition: RelativePosition, relativeAttitude: RelativeAttitude, absoluteAttitude: AbsoluteAttitude): void;
+}
+declare const _default: GeoRelativePositionFromArCoreProvider;
+export default _default;

package/dist/src/providers/position/relative/GeoRelativePositionProvider.d.ts

@@ -0,0 +1,12 @@
+import { GeoRelativePosition } from '@wemap/geo';
+import { default as Provider } from '../../Provider.js';
+declare class GeoRelativePositionProvider extends Provider<GeoRelativePosition> {
+    providerId?: number;
+    geoRelativeProvider?: Provider<GeoRelativePosition>;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): Promise<void>;
+    stop(): void;
+}
+declare const _default: GeoRelativePositionProvider;
+export default _default;

package/dist/src/providers/position/relative/PdrProvider.d.ts

@@ -0,0 +1,15 @@
+import { GeoRelativePosition } from '@wemap/geo';
+import { default as Provider } from '../../Provider.js';
+declare class PdrProvider extends Provider<GeoRelativePosition> {
+    private absoluteAttitudeProviderId?;
+    private stepDetectionProviderId?;
+    private attitudeEvent?;
+    private misalignmentError;
+    getName: () => string;
+    availability(): import('../../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    private onStepEvent;
+}
+declare const _default: PdrProvider;
+export default _default;

package/dist/src/providers/steps/StepDetectionLadetto.d.ts

@@ -0,0 +1,15 @@
+import { Vector3_t } from '@wemap/maths';
+declare class StepDetectionLadetto {
+    static MIN_TIME_BETWEEN_STEPS: number;
+    static MAX_FRENQUENCY: number;
+    static MIN_FRENQUENCY: number;
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD: number;
+    frequency: number;
+    lastVerticalAcc: number;
+    maxAcceleration: number;
+    lastStepTimestamp: number;
+    compute(timestamp: number, linearAcc: Vector3_t): boolean;
+    get lastStepSize(): number;
+    get speed(): number;
+}
+export default StepDetectionLadetto;

package/dist/src/providers/steps/StepDetectionMinMaxPeaks.d.ts

@@ -0,0 +1,19 @@
+import { Vector3_t } from '@wemap/maths';
+declare class StepDetectionMinMaxPeaks {
+    static WINDOW_TIME: number;
+    static MIN_TIME_BETWEEN_STEPS: number;
+    static MAX_FRENQUENCY: number;
+    static MIN_FRENQUENCY: number;
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD: number;
+    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD: number;
+    frequency: number;
+    lastStepTimestamp: number;
+    slidingWindow: {
+        timestamp: number;
+        verticalAcc: number;
+    }[];
+    compute(timestamp: number, linearAcc: Vector3_t): boolean;
+    get lastStepSize(): number;
+    get speed(): number;
+}
+export default StepDetectionMinMaxPeaks;

package/dist/src/providers/steps/StepDetectionMinMaxPeaks2.d.ts

@@ -0,0 +1,27 @@
+import { Vector3_t } from '@wemap/maths';
+declare class StepDetectionMinMaxPeaks2 {
+    static WINDOW_TIME: number;
+    static MIN_TIME_BETWEEN_STEPS: number;
+    static MAX_FRENQUENCY: number;
+    static MIN_FRENQUENCY: number;
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD: number;
+    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD: number;
+    frequency: number;
+    influence: number;
+    slidingWindow: {
+        timestamp: number;
+        verticalAcc: number;
+    }[];
+    lastStepTimestamp: number;
+    previousVerticalAcc: number;
+    compute(timestamp: number, linearAcc: Vector3_t, angularRate: Vector3_t): boolean;
+    get lastStepSize(): number;
+    get speed(): number;
+    mean(data: {
+        verticalAcc: number;
+    }[]): number;
+    stddev(data: {
+        verticalAcc: number;
+    }[]): number;
+}
+export default StepDetectionMinMaxPeaks2;

package/dist/src/providers/steps/StepDetectionMinMaxPeaks3.d.ts

@@ -0,0 +1,24 @@
+import { Vector3_t } from '@wemap/maths';
+declare class StepDetectionMinMaxPeaks3 {
+    static WINDOW_TIME: number;
+    static MIN_TIME_BETWEEN_STEPS: number;
+    static MAX_FRENQUENCY: number;
+    static MIN_FRENQUENCY: number;
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD: number;
+    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD: number;
+    frequency: number;
+    influence: number;
+    slidingWindow: {
+        timestamp: number;
+        verticalAcc: number;
+    }[];
+    lastStepTimestamp: number;
+    previousVerticalAcc: number;
+    previousHorizontalAcc: number;
+    compute(timestamp: number, linearAcc: Vector3_t): boolean;
+    get lastStepSize(): number;
+    get speed(): number;
+    mean(data: number[]): number;
+    stddev(data: number[]): number;
+}
+export default StepDetectionMinMaxPeaks3;

package/dist/src/providers/steps/StepProvider.d.ts

@@ -0,0 +1,36 @@
+import { Quaternion_t, Vector3_t } from '@wemap/maths';
+import { default as Provider } from '../Provider.js';
+import { Acceleration, AngularRate, RelativeAttitude, Step } from '../../events/Types.js';
+type StepDetectorAlgorithmName = 'ladetto' | 'minMaxPeaks' | 'minMaxPeaks2' | 'minMaxPeaks3';
+type StepDetectorAlgorithm = {
+    compute(timestamp: number, linearAcc: Vector3_t, angularRate?: Vector3_t): boolean;
+    lastStepSize: number;
+};
+declare class StepProvider extends Provider<Step> {
+    static DEFAULT_STEP_SIZE_MULTIPLIER: number;
+    static DEFAULT_ALGORITHM: StepDetectorAlgorithmName;
+    accelerometerProviderId?: number;
+    attitudeProviderId?: number;
+    gyroscopeProviderId?: number;
+    angularRateEvent?: AngularRate;
+    attitudeEvent?: RelativeAttitude;
+    numOfSteps: number;
+    stepDetector: StepDetectorAlgorithm;
+    _stepSizeMultiplier: number;
+    _algorithm: StepDetectorAlgorithmName;
+    _accValues: Vector3_t[];
+    constructor();
+    getName: () => string;
+    availability(): import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    onAccelerometerEvent: (accelerationEvent: Acceleration) => void;
+    static computeLinearAcceleration(quaternion: Quaternion_t, acc: Vector3_t): Vector3_t;
+    set stepSizeMultiplier(stepSizeMultiplier: number);
+    get stepSizeMultiplier(): number;
+    set algorithm(algorithm: StepDetectorAlgorithmName);
+    get algorithm(): StepDetectorAlgorithmName;
+}
+export declare function createStepProvider(algorithm: StepDetectorAlgorithmName): StepProvider;
+declare const _default: StepProvider;
+export default _default;

package/dist/src/providers/steps/StraightLineProvider.d.ts

@@ -0,0 +1,21 @@
+import { default as Provider } from '../Provider.js';
+import { StraightLine } from '../../events/Types.js';
+declare class StraightLineProvider extends Provider<StraightLine> {
+    static DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE: number;
+    _turnProviderId?: number;
+    _stepProviderId?: number;
+    _countSteps: number;
+    _stepsConsideredForStraightLine: number;
+    getName: () => string;
+    availability(): import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+    private _onTurn;
+    private _onStep;
+    isStraight(): boolean;
+    get numStepsDetectedFromLastTurn(): number;
+    get stepsConsideredForStraightLine(): number;
+    set stepsConsideredForStraightLine(stepsConsideredForStraightLine: number);
+}
+declare const _default: StraightLineProvider;
+export default _default;

package/dist/src/providers/vision/ArCoreProvider.d.ts

@@ -0,0 +1,50 @@
+import { RelativePosition } from '@wemap/geo';
+import { default as Provider } from '../Provider.js';
+import { default as MissingArCoreError } from '../../errors/MissingArCoreError.js';
+import { NativeArCore } from '../NativeProviders.js';
+import { Barcode, CameraProjectionMatrix, RelativeAttitude } from '../../events/Types.js';
+export type Payload = [number, ...[number | string]];
+export type ArCoreEvent = Readonly<{
+    readonly relativePosition: RelativePosition;
+    readonly relativeAttitude: RelativeAttitude;
+    readonly cameraProjection?: CameraProjectionMatrix;
+    readonly barcode?: Barcode;
+}>;
+declare class ArCoreProvider extends Provider<ArCoreEvent> {
+    static Payload: {
+        readonly Pose: {
+            readonly ref: number;
+            readonly size: 7;
+        };
+        readonly Barcode: {
+            readonly ref: number;
+            readonly size: 1;
+        };
+        readonly ProjMat: {
+            readonly ref: number;
+            readonly size: 16;
+        };
+        readonly ImageRef: {
+            readonly ref: number;
+            readonly size: 1;
+        };
+    };
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    static RELATIVE_ATTITUDE_DRIFT: number;
+    _nativeProvider?: NativeArCore;
+    previousPosition: number[];
+    getName: () => string;
+    availability(): Promise<void> | Promise<MissingArCoreError>;
+    start(): void;
+    stop(): void;
+    pullDataLoop: () => void;
+    parsePayload(payload: Payload): void;
+    get nativeProvider(): NativeArCore;
+    enableBarcodeScanner(): void;
+    disableBarcodeScanner(): void;
+    get useCameraNatively(): boolean;
+}
+declare const _default: ArCoreProvider;
+export default _default;

package/dist/src/providers/vision/BarcodeProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as Provider } from '../Provider.js';
+import { Barcode } from '../../events/Types.js';
+declare class BarcodePoleStarProvider extends Provider<Barcode> {
+    providerId?: number;
+    getName: () => string;
+    availability: () => import('../../events/AvailabilityHelper.js').AvailabilityPromise;
+    start(): void;
+    stop(): void;
+}
+declare const _default: BarcodePoleStarProvider;
+export default _default;

package/dist/src/providers/vision/vps/ImageRelocalization.d.ts

@@ -0,0 +1,11 @@
+import { Calibration } from '@wemap/camera';
+import { Quaternion_t } from '@wemap/maths/index.js';
+import { CoarsePose } from './VpsMetadata.js';
+import { default as VpsRequest } from './VpsRequest.js';
+import { default as VpsResponse } from './VpsResponse.js';
+declare class ImageRelocalization {
+    static _prepareRequest(imageCanvas: HTMLCanvasElement, calibration?: Calibration | null, coarsePose?: CoarsePose | null): VpsRequest;
+    static relocalize(endpointUrl: string, imageCanvas: HTMLCanvasElement, calibration?: Calibration | null, coarsePose?: CoarsePose | null, customHeaders?: Record<string, string> | null): Promise<VpsResponse | null>;
+    static getHeadingFromQuaternion(quaternion: Quaternion_t): number;
+}
+export default ImageRelocalization;

package/dist/src/providers/vision/vps/RelativeRotationCalc.d.ts

@@ -0,0 +1,10 @@
+import { Attitude } from '@wemap/geo';
+export default class RelativeRotationCalc {
+    _providerId?: number;
+    _isRunning: boolean;
+    _dataOnStart: Attitude | null;
+    tickStart(): void;
+    tickEnd(): Attitude | null;
+    _internalStop(): void;
+    release(): void;
+}