@scandit/web-datacapture-core 7.0.0-beta.1

package/build/js/Camera-Cxbduq94.d.ts

@@ -0,0 +1,1700 @@
+/// <reference types="emscripten" />
+import { Serializable } from './private/Serializable.js';
+import { WatermarkStack } from './private/FrameReaders/WatermarkStack.js';
+import { Optional, MethodSignature } from './tsHelper.js';
+import { Size, Orientation, MarginsWithUnitJSON, PointWithUnitJSON, Anchor, MarginsWithUnit, PointWithUnit, Point, Quadrilateral, JSONType, RectJSON, PointJSON } from './Common.js';
+import { DataCaptureContextSettings, DataCaptureContextSettingsJSON } from './DataCaptureContextSettings.js';
+import { LogoStyle, FocusGestureJSON, ZoomGestureJSON, FocusGesture, ZoomGesture } from './DataCaptureViewPlusRelated.js';
+import { Control } from './ViewControls.js';
+import { DidTapCustomLocationsViewListener, StateToRender } from './private/CustomLocationsView.js';
+import { AnchorPositions } from './private/AnchorPositions.js';
+import { OpenSourceSoftwareLicenseInfo } from './license/OpenSourceSoftwareLicenseInfo.js';
+import { HTMLElementStateJSON } from './private/HtmlElementState.js';
+import { OverrideState } from './worker/OverrideState.js';
+import { Logger } from './logger.js';
+import { ProgressInfo } from './LoadingStatus.js';
+
+declare enum CameraPosition$1 {
+    WorldFacing = "worldFacing",
+    UserFacing = "userFacing"
+}
+declare enum CameraResolutionConstraint$1 {
+    ULTRA_HD = 0,
+    FULL_HD = 1,
+    HD = 2,
+    SD = 3,
+    NONE = 4
+}
+declare enum AspectRatio {
+    AUTO = "auto",
+    FOUR_TO_THREE = "fourToThree",
+    SIXTEEN_TO_NINE = "sixteenToNine"
+}
+interface DeviceCamera$1 {
+    position: CameraPosition$1;
+    label: string;
+    deviceId: string;
+    currentResolution?: VideoFrameResolution;
+}
+/**
+ * A helper object to interact with cameras.
+ */
+declare namespace CameraAccess$1 {
+    /**
+     * Overrides for main camera for a given camera position on a desktop/laptop device, set when accessing an initial camera.
+     */
+    const mainCameraForPositionOverridesOnDesktop: Map<CameraPosition$1, DeviceCamera$1>;
+    /**
+     *
+     * To be accessed directly only for tests.
+     *
+     * The mapping from deviceIds to camera objects.
+     */
+    const deviceIdToCameraObjects: Map<string, DeviceCamera$1>;
+    /**
+     *
+     * To be accessed directly only for tests.
+     *
+     * The list of inaccessible deviceIds.
+     */
+    const inaccessibleDeviceIds: Set<string>;
+    function setMainCameraForPositionOverridesOnDesktop(cameraPosition: CameraPosition$1, deviceCamera: DeviceCamera$1): void;
+    /**
+     * used mainly for testing
+     */
+    function clearMainCameraForPositionOverridesOnDesktop(): void;
+    /**
+     *
+     * @param label The camera label.
+     * @returns Whether the label identifies the camera being the iOS front (main) camera one.
+     */
+    function isIOSFrontCameraLabel(label: string): boolean;
+    /**
+     *
+     * @param label The camera label.
+     * @returns Whether the label identifies the camera being the iOS back (main) camera one.
+     */
+    function isIOSBackCameraLabel(label: string): boolean;
+    /**
+     *
+     * @param label The camera label.
+     * @returns Whether the label identifies the camera being the iOS Back Dual camera one.
+     */
+    function isIOSBackDualWideCameraLabel(label: string): boolean;
+    /**
+     *
+     * @param label The camera label.
+     * @returns Whether the label identifies the camera being the iOS UltraWide back camera one.
+     */
+    function isIOSUltraWideBackCameraLabel(label: string): boolean;
+    /**
+     *
+     * Get the main camera for the given camera position.
+     *
+     * @param cameras The array of available [[DeviceCamera]] objects.
+     * @param cameraPosition The wanted camera position.
+     * @returns The main camera matching the wanted camera position.
+     */
+    function getMainCameraForPosition(cameras: DeviceCamera$1[], cameraPosition: CameraPosition$1): DeviceCamera$1 | undefined;
+    /**
+     *
+     * Sort the given cameras in order of priority of access based on the given camera position.
+     *
+     * @param cameras The array of available [[DeviceCamera]] objects.
+     * @param cameraPosition The preferred camera position.
+     * @returns The sorted cameras.
+     */
+    function sortCamerasForCameraPosition<DeviceCameraLike extends DeviceCamera$1 = DeviceCamera$1>(cameras: DeviceCameraLike[], cameraPosition: CameraPosition$1): DeviceCameraLike[];
+    /**
+     *
+     * Adjusts the camera's information based on the given currently active video stream.
+     *
+     * @param mediaStream The currently active `MediaStream` object.
+     * @param camera The currently active [[Camera]] object associated with the video stream.
+     */
+    function adjustCameraFromMediaStream(mediaStream: MediaStream, camera: DeviceCamera$1): void;
+    /**
+     * Get a list of cameras (if any) available on the device, a camera access permission is requested to the user
+     * the first time this method is called if needed.
+     *
+     * If the user denies the necessary camera access permission, a list of cameras with the correct amount of devices is
+     * returned in any case, but the cameras will have no available (empty) label and deviceId and can thus not be
+     * accessed.
+     *
+     * If the browser is incompatible the returned promise is rejected with a `UnsupportedBrowserError` error.
+     *
+     * When refreshing available devices, if updated deviceId information is detected, cameras' deviceId are updated
+     * accordingly. This could happen after a camera access and stop in some situations.
+     *
+     * @param refreshDevices Force a call to refresh available video devices even when information is already available.
+     * @param cameraAlreadyAccessed Hint that a camera has already been accessed before, avoiding a possible initial
+     * camera access permission request on the first call, in cases this cannot be already reliably detected.
+     * @returns A promise resolving to the array of available [[Camera]] objects (could be empty).
+     */
+    function getCameras(refreshDevices?: boolean, cameraAlreadyAccessed?: boolean): Promise<DeviceCamera$1[]>;
+    /**
+     *
+     * Get the *getUserMedia* *video* parameters to be used given a resolution fallback level and the browser used.
+     *
+     * @param cameraResolutionConstraint The resolution constraint.
+     * @returns The resulting *getUserMedia* *video* parameters.
+     */
+    function getUserMediaVideoParameters(cameraResolutionConstraint: CameraResolutionConstraint$1, preferredAspectRatio?: AspectRatio): MediaTrackConstraints;
+    /**
+     *
+     * Mark a camera to be inaccessible and thus excluded from the camera list returned by [[getCameras]].
+     *
+     * @param camera The camera to mark to be inaccessible.
+     */
+    function markCameraAsInaccessible(camera: DeviceCamera$1): void;
+    /**
+     *
+     * Try to access a given camera for video input at the given resolution level.
+     *
+     * If a camera is inaccessible because of errors, then it's added to the inaccessible device list. If the specific
+     * error is of type `OverconstrainedError` or `NotReadableError` however, this procedure is done later on via a
+     * separate external logic; also, in case of an error of type `NotAllowedError` (permission denied) this procedure is
+     * not executed, in order to possibly recover if and when the user allows the camera to be accessed again.
+     * This is done to allow checking if the camera can still be accessed via an updated deviceId when deviceId
+     * information changes, or if it should then be confirmed to be considered inaccessible.
+     *
+     * Depending on parameters, device features and user permissions for camera access, any of the following errors
+     * could be the rejected result of the returned promise:
+     * - `AbortError`
+     * - `NotAllowedError`
+     * - `NotFoundError`
+     * - `NotReadableError`
+     * - `SecurityError`
+     * - `OverconstrainedError`
+     *
+     * @param cameraResolutionConstraint The resolution constraint.
+     * @param camera The camera to try to access for video input.
+     * @returns A promise resolving to the `MediaStream` object coming from the accessed camera.
+     */
+    function accessCameraStream(camera: DeviceCamera$1, cameraResolutionConstraint: CameraResolutionConstraint$1, preferredAspectRatio?: AspectRatio): Promise<MediaStream>;
+}
+
+/**
+ * these are the public exports from CameraAccess
+ */
+declare namespace CameraAccess {
+    function getCameras(refreshDevices?: boolean, cameraAlreadyAccessed?: boolean): Promise<DeviceCamera[]>;
+}
+interface DeviceCamera {
+    position: CameraPosition$1;
+    label: string;
+    deviceId: string;
+}
+
+declare enum FrameSourceState {
+    On = "on",
+    Off = "off",
+    Standby = "standby",
+    Starting = "starting",
+    Stopping = "stopping",
+    BootingUp = "bootingUp",
+    WakingUp = "wakingUp",
+    GoingToSleep = "goingToSleep",
+    ShuttingDown = "shuttingDown"
+}
+declare enum TorchState {
+    On = "on",
+    Off = "off"
+}
+declare enum CameraPosition {
+    WorldFacing = "worldFacing",
+    UserFacing = "userFacing"
+}
+declare enum VideoResolution {
+    Auto = "auto",
+    HD = "hd",
+    FullHD = "fullHd",
+    UHD4K = "uhd4k"
+}
+declare enum FocusGestureStrategy {
+    None = "none",
+    Manual = "manual",
+    ManualUntilCapture = "manualUntilCapture",
+    AutoOnLocation = "autoOnLocation"
+}
+interface FrameSourceListener {
+    didChangeState?: (frameSource: FrameSource, newState: FrameSourceState) => void;
+}
+interface FrameSourceJSON {
+    type: string;
+}
+interface FrameSource extends Serializable<FrameSourceJSON> {
+    readonly desiredState: FrameSourceState;
+    getCurrentState: () => FrameSourceState;
+    switchToDesiredState: (desiredState: FrameSourceState) => Promise<void>;
+    addListener: (listener: FrameSourceListener) => void;
+    removeListener: (listener: FrameSourceListener) => void;
+}
+interface CameraSettingsJSONBase {
+    preferredResolution: string;
+    zoomFactor: number;
+    zoomGestureZoomFactor: number;
+    api?: number;
+}
+interface CameraSettingsFromJSON extends CameraSettingsJSONBase {
+    focusGestureStrategy: string;
+}
+interface CameraSettingsJSON extends CameraSettingsJSONBase {
+    focus: {
+        focusGestureStrategy: string;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+declare function isCameraFrameSource(frameSource?: FrameSource | null): frameSource is Camera;
+declare class CameraSettings implements Serializable<CameraSettingsJSON> {
+    preferredResolution: VideoResolution;
+    zoomFactor: number;
+    zoomGestureZoomFactor: number;
+    private focus;
+    get focusGestureStrategy(): FocusGestureStrategy;
+    set focusGestureStrategy(newStrategy: FocusGestureStrategy);
+    private static fromJSON;
+    constructor();
+    constructor(settings: CameraSettings);
+    setProperty(name: string, value: any): void;
+    getProperty(name: string): any;
+    /**
+     * The resulting JSON must also contain properties set on the object itself ("hidden" properties)
+     */
+    toJSONObject(): CameraSettingsJSON & Record<string, any>;
+}
+
+declare abstract class FrameReaderAbstract {
+    colorType: ColorType;
+    protected readonly _contextWebGL: WebGLRenderingContext;
+    protected readonly _maxPoolCapacity: number;
+    protected readonly _minPoolCapacity: number;
+    /**
+     * In mobile applications, particularly on Android, capturing frames at a slow rate can be a common issue,
+     * especially in scenarios involving barcode tracking. Using a stack becomes valuable in such situations
+     * because it allows us to capture next frame with pixel data while the engine is still processing the previous one,
+     * eliminating the need to wait for the engine to finish before capturing the next frame.
+     */
+    protected _framePool: Optional<WatermarkStack<Uint8ClampedArray>>;
+    constructor(contextWebGL: WebGLRenderingContext, options?: {
+        maxPoolCapacity: number;
+        minPoolCapacity: number;
+    } | undefined);
+    abstract readFromSource(source: TexImageSource): FrameCapture;
+    abstract setup(): void;
+    recycle(pixelsData: Uint8ClampedArray): void;
+    abstract dispose(): void;
+}
+
+declare enum ColorType {
+    RGBA = "RGBA",
+    GRAYSCALE = "GRAYSCALE"
+}
+declare class FrameReader extends FrameReaderAbstract {
+    colorType: ColorType;
+    private _framebuffer;
+    private _texture;
+    private _frameSize;
+    private get _initialized();
+    readFromSource(source: TexImageSource): FrameCapture;
+    setup(): void;
+    dispose(): void;
+    private updateFrameSizeIfNeeded;
+}
+
+interface DataCaptureContextListener {
+    didChangeStatus?: (context: DataCaptureContext$1, contextStatus: ContextStatus) => void;
+    didStartObservingContext?: (context: DataCaptureContext$1) => void;
+    didChangeFrameSource?: (context: DataCaptureContext$1, frameSource: FrameSource | null) => void;
+}
+interface ContextStatusJSON {
+    code: number;
+    isValid: boolean;
+    message: string;
+}
+declare class ContextStatus {
+    private _message;
+    private _code;
+    private _isValid;
+    private static fromJSON;
+    get message(): string;
+    get code(): number;
+    get isValid(): boolean;
+}
+declare enum PrivateMirrorAxis {
+    None = "None",
+    X = "X",
+    Y = "Y"
+}
+
+interface DataCaptureOverlay extends Serializable {
+    toJSONObject: () => any;
+}
+interface DataCaptureViewListener {
+    didChangeSize?: (view: DataCaptureView$1, size: Size, orientation: Orientation) => void;
+}
+interface DataCaptureViewJSON {
+    scanAreaMargins: MarginsWithUnitJSON;
+    pointOfInterest: PointWithUnitJSON;
+    logoAnchor: Anchor;
+    logoOffset: PointWithUnitJSON;
+    logoHidden: boolean;
+    logoStyle: LogoStyle;
+    overlays: any[];
+    controls: any[];
+    focusGesture: FocusGestureJSON | null;
+    zoomGesture: ZoomGestureJSON | null;
+}
+declare class DataCaptureView$1 implements Serializable<DataCaptureViewJSON> {
+    focusGesture: FocusGesture | null;
+    zoomGesture: ZoomGesture | null;
+    private _scanAreaMargins;
+    private _pointOfInterest;
+    private _logoStyle;
+    private _logoAnchor;
+    private _logoOffset;
+    private _context;
+    private readonly overlays;
+    private readonly controls;
+    private gestureRecognizer;
+    private readonly controlWidgets;
+    private containerElement;
+    private cameraPaintboardElement?;
+    private singleImageUploaderPaintboardElement?;
+    private videoElement?;
+    private visibilityListener;
+    private videoPauseListener;
+    private cameraRecoveryListener;
+    private controlsElement;
+    private cameraRecoveryElement;
+    private errorElement;
+    private hintContainerElement;
+    private hintElement;
+    private canvasElement;
+    private frozenFrame;
+    private frozenFrameCanvas;
+    private _canvasDrawer;
+    private readonly listeners;
+    private htmlElement?;
+    private htmlElementState?;
+    private lastHtmlElementState;
+    private isVideoElementDetached;
+    private loadingOverlay;
+    private customLocationsView;
+    private lastFrameSourceState;
+    private singleImageUploaderView;
+    private orientation;
+    private hiddenProperties;
+    private orientationObserver;
+    private onOrientationChangeListener;
+    private hintPresenter;
+    private onHintPresenterUpdateHandler;
+    private onBeforeShowToastsHandler;
+    private onWorkerMessageHandler;
+    private localizationSubscription?;
+    constructor();
+    get scanAreaMargins(): MarginsWithUnit;
+    set scanAreaMargins(margins: MarginsWithUnit);
+    get pointOfInterest(): PointWithUnit;
+    set pointOfInterest(pointOfInterest: PointWithUnit);
+    get logoStyle(): LogoStyle;
+    set logoStyle(logoStyle: LogoStyle);
+    get logoAnchor(): Anchor;
+    set logoAnchor(logoAnchor: Anchor);
+    get logoOffset(): PointWithUnit;
+    set logoOffset(logoOffset: PointWithUnit);
+    private get cameraRecoveryText();
+    private get width();
+    private get height();
+    private get canvasDrawer();
+    /**
+     * The current context as a PrivateDataCaptureContext
+     */
+    private get privateContext();
+    static forContext(context: DataCaptureContext$1 | null): Promise<DataCaptureView$1>;
+    showProgressBar(): void;
+    hideProgressBar(): void;
+    setProgressBarPercentage(percentage: number | null): void;
+    setProgressBarMessage(message: string): void;
+    getContext(): DataCaptureContext$1 | null;
+    setContext(context: DataCaptureContext$1 | null): Promise<void>;
+    connectToElement(element: HTMLElement): void;
+    detachFromElement(): void;
+    addOverlay(overlay: DataCaptureOverlay): Promise<void>;
+    removeOverlay(overlay: DataCaptureOverlay): Promise<void>;
+    addListener(listener: DataCaptureViewListener): void;
+    removeListener(listener: DataCaptureViewListener): void;
+    /**
+     * Converts a point in the coordinate system of the last visible frame and maps it to a coordinate in the view.
+     * It does *not* take into account if the frameSource is mirrored.
+     */
+    viewPointForFramePoint(point: Point): Point;
+    viewQuadrilateralForFrameQuadrilateral(quadrilateral: Quadrilateral): Quadrilateral;
+    addControl(control: Control): void;
+    removeControl(control: Control): void;
+    toJSONObject(): DataCaptureViewJSON;
+    isCameraRecoveryVisible(): boolean;
+    setCameraRecoveryVisible(visible: boolean): void;
+    allowPictureInPicture(allow: boolean): Promise<void>;
+    protected viewAnchorPositionsForFrameAnchorPositions(anchorPositions: AnchorPositions): AnchorPositions;
+    protected setDidTapCustomLocationsViewListener(didTapViewListener: DidTapCustomLocationsViewListener): void;
+    protected renderCustomLocationsView(state: StateToRender): void;
+    private removeStyles;
+    private onHintPresenterUpdate;
+    private clearHtmlElementContent;
+    private setupHtmlElement;
+    private setupHtmlElementSingleImageUploader;
+    private setupHtmlElementVisibility;
+    private createStyles;
+    private onOrientationChange;
+    private htmlElementDidChange;
+    private htmlElementDisconnected;
+    private handleVideoDisplay;
+    private isCanvasDrawerWithMetrics;
+    private onWorkerMessage;
+    private onBeforeShowToasts;
+    private drawEngineCommands;
+    private displayError;
+    private clearError;
+    private displayHint;
+    private hideHint;
+    private updateHint;
+    private updateAnchor;
+    private controlsUpdated;
+    private redrawControls;
+    /**
+     * Allows capture modes to register their own widgets so that they can be added to the view.
+     */
+    private registerControlWidget;
+    private getControlWidget;
+    private onFrameSourceChange;
+    private onCameraStateChanged;
+    private setVideoElementOpacity;
+    private onSingleImageUploaderSettingsChange;
+    private handleVideoPause;
+    private setHiddenProperty;
+    private onVisibilityChange;
+    private cameraRecovery;
+    private freezeFrame;
+    private unfreezeFrame;
+}
+
+type CommandAndPayload<A, C> = A extends {
+    command: C;
+} ? A : never;
+type WorkerCommandPayload<C> = Omit<CommandAndPayload<AnyDataCaptureActionMessage, C>, "command" | "id">;
+type WorkerListener = (event: DataCaptureCallbackMessage) => any;
+interface DataCaptureLoaderOptions {
+    libraryLocation: string;
+    verifyResponseHash: boolean;
+    preloadEngine?: boolean;
+    loadProgressNotifier?: (info: ProgressInfo) => void;
+    logLevel?: Logger.Level;
+    overrideSimdSupport: OverrideState;
+    overrideThreadsSupport: OverrideState;
+    highEndBlurryRecognition?: boolean;
+}
+/**
+ * The DataCaptureLoader class is used by the main thread, it instantiates the worker
+ * and sends commands to it. It represents thus the main communication channel
+ * between the main thread and the engine running in the worker.
+ */
+declare class DataCaptureLoader {
+    highEndBlurryRecognition?: boolean;
+    protected overrideThreadsSupport: OverrideState;
+    protected overrideSimdSupport: OverrideState;
+    protected verifyResponseHash: boolean;
+    protected _dataCaptureWorker?: DataCaptureWorker;
+    protected readonly libraryLocation: string;
+    /**
+     * Mainly useful for FS when merging preloaded data (blurry tables preloading).
+     */
+    protected readonly isPreloadEngine: boolean;
+    protected workerCommandId: number;
+    protected readonly workerTasks: Map<number, {
+        resolve: (...arguments_: any[]) => any;
+        reject: (...arguments_: any[]) => any;
+        command: string;
+    }>;
+    protected readonly workerListeners: WorkerListener[];
+    protected workerMessageListener: (event_: MessageEvent<DataCaptureCallbackMessage>) => void;
+    protected constructor(options: DataCaptureLoaderOptions);
+    get dataCaptureWorker(): DataCaptureWorker;
+    protected get name(): string;
+    static create(options: DataCaptureLoaderOptions): Promise<DataCaptureLoader>;
+    load(): Promise<WorkerResponse<"loadLibrary">>;
+    /**
+     * Send a task (i.e. a command) to the worker. Every task sent has a corresponding Promise object which
+     * gets resolved when the worker has processed the request. The tasks are identified by an id which is
+     * sent along with the data by both sides.
+     */
+    workerCommand<C extends DataCaptureActionMessageKey>(command: C, payload: WorkerCommandPayload<C>, transferables?: Transferable[]): Promise<WorkerResponse<C>>;
+    terminateDataCaptureWorker(disposeContext?: boolean): Promise<void>;
+    addWorkerListener(listener: WorkerListener): void;
+    removeWorkerListener(listener: WorkerListener): void;
+    getOptions(): Pick<DataCaptureLoaderOptions, "libraryLocation" | "overrideSimdSupport" | "overrideThreadsSupport" | "verifyResponseHash">;
+    protected onWorkerMessage(event_: MessageEvent<DataCaptureCallbackMessage>): void;
+}
+
+type Change = {
+    type: "modeEnabled";
+    newValue: boolean;
+} | {
+    type: "addControl";
+    newValue: any;
+} | {
+    type: "addOverlay";
+    newValue: any;
+} | {
+    type: "cameraSettings";
+    newValue: any;
+} | {
+    type: "frameSourceState";
+    newValue: any;
+} | {
+    type: "removeControl";
+    newValue: any;
+} | {
+    type: "removeOverlay";
+    newValue: any;
+} | {
+    type: "singleImageModeUploaderSettings";
+    newValue: any;
+} | {
+    type: "torchState";
+    newValue: any;
+} | {
+    type: "viewChange";
+    newValue: {
+        orientation: Orientation;
+    } & Partial<HTMLElementStateJSON>;
+} | {
+    type: "viewSet";
+    newValue: DataCaptureView$1 | null;
+};
+type PrivateChangeSet = Change[];
+interface PrivateDataCaptureMode {
+    type: "barcodeCapture" | "idCapture";
+    skipSerialization: boolean;
+    _context: Optional<DataCaptureContext$1>;
+    attachedToContext: (context: DataCaptureContext$1) => Promise<void>;
+    detachedFromContext: () => Promise<void>;
+}
+interface DataCaptureMode extends Serializable {
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): Promise<void>;
+    context: Optional<DataCaptureContext$1>;
+}
+interface DataCaptureModeJSON<S = JSONType> {
+    type: "barcodeCapture" | "barcodeTracking" | "idCapture" | "parser" | "sparkScan" | "barcodeFind";
+    enabled: boolean;
+    settings: S;
+}
+interface PrivateDataCaptureComponent {
+    _context: DataCaptureContext$1;
+}
+type DataCaptureComponentJSON = JSONType;
+interface DataCaptureComponent extends Serializable<DataCaptureComponentJSON> {
+    readonly id: string;
+}
+interface PrivateDataCaptureContextOptions {
+    deviceName?: string | null;
+    dataCaptureInstance?: DataCaptureLoader;
+    delayedRegistration?: boolean;
+}
+interface PrivateDataCaptureContext<W extends (...parameters: any[]) => unknown = DataCaptureLoader["workerCommand"]> {
+    _frameSource?: FrameSource | null;
+    modes: Set<DataCaptureMode>;
+    components: DataCaptureComponent[];
+    initialize: () => Promise<void>;
+    update: (changeSet?: PrivateChangeSet) => Promise<void>;
+    addComponent: (component: DataCaptureComponent) => Promise<void>;
+    dataCaptureInstance: DataCaptureLoader;
+    sendFrameToProcessor: (capture: FrameCapture) => Promise<WorkerResponse<"processFrame">>;
+    subscribeToWorkerMessages: (listener: (message: DataCaptureCallbackMessage) => void) => void;
+    unsubscribeToWorkerMessages: (listener: (message: DataCaptureCallbackMessage) => void) => void;
+    hasEnabledMode: () => boolean;
+    workerCommand: MethodSignature<W>;
+    performanceMark: MethodSignature<DataCaptureContext$1["performanceMark"]>;
+    isFeatureSupported: (feature: LicensedFeature) => Promise<boolean>;
+    new (licenseKey: string, options: PrivateDataCaptureContextOptions): DataCaptureContext$1;
+    updateListeners: Set<(change: Change) => void>;
+}
+interface DataCaptureContextCreationOptions {
+    deviceName?: string;
+    licenseKey?: string;
+    settings?: DataCaptureContextSettings;
+}
+interface RuntimeEnvironment {
+    deviceOS: string;
+    browser: string;
+    browserVersion: string;
+    deviceModelName: string;
+}
+interface DataCaptureContextJSON extends RuntimeEnvironment {
+    framework: string;
+    settings: DataCaptureContextSettingsJSON;
+    licenseKey: string;
+    deviceName: string;
+    frameSource: FrameSourceJSON | null;
+    modes: DataCaptureModeJSON[];
+    components: DataCaptureComponentJSON[];
+    view: DataCaptureViewJSON | null;
+}
+type PrivateFrameHandlerResponse = "continue" | "skip";
+type PrivateFrameHandler = (frame: FrameCapture) => Promise<PrivateFrameHandlerResponse>;
+declare class DataCaptureContext$1 implements Serializable<DataCaptureContextJSON> {
+    static deviceID: string;
+    private static readonly moduleLicenseTextProviders;
+    private readonly framework;
+    private readonly runtimeEnvironment;
+    private settings;
+    private readonly licenseKey;
+    private readonly deviceName;
+    private _frameSource;
+    private _view;
+    private readonly modes;
+    private readonly components;
+    private readonly listeners;
+    private readonly updateListeners;
+    private readonly cameraPropertiesReportListener;
+    private readonly cameraAccessErrorListener;
+    private readonly onWorkerMessageListener;
+    private readonly onVisibilityChangeListener;
+    private readonly dataCaptureInstance;
+    private readonly delayedRegistration;
+    private readonly highEndBlurryRecognition;
+    private readonly _frameHandlers;
+    private constructor();
+    get frameSource(): FrameSource | null;
+    private get workerCommand();
+    static create(): Promise<DataCaptureContext$1>;
+    static createWithOptions(options: DataCaptureContextCreationOptions): Promise<DataCaptureContext$1>;
+    static getOpenSourceSoftwareLicenseInfo(): Promise<OpenSourceSoftwareLicenseInfo>;
+    /**
+     * Disconnect the current frame source from the context and connect the new one. This process can happen multiple
+     * times for the same frame source because of its initialisation (The mirroring info of a camera is only available
+     * when it has started for example).
+     * Trigger the "didChangeFrameSource" listeners only if the new frame source is different than the old one.
+     */
+    setFrameSource(frameSource: FrameSource | null): Promise<void>;
+    addListener(listener: DataCaptureContextListener): void;
+    flushAnalytics(): Promise<void>;
+    removeListener(listener: DataCaptureContextListener): void;
+    addMode(mode: DataCaptureMode): Promise<void>;
+    removeMode(mode: DataCaptureMode): Promise<void>;
+    removeAllModes(): Promise<void>;
+    dispose(): Promise<void>;
+    applySettings(settings: DataCaptureContextSettings): Promise<void>;
+    toJSONObject(): DataCaptureContextJSON;
+    private getView;
+    private setView;
+    private getAppName;
+    private urlToHostname;
+    private getParentDomain;
+    private initialize;
+    private subscribeToVisibilityChange;
+    private unsubscribeToVisibilityChange;
+    private requestFrameData;
+    private performanceMark;
+    private sendFrameToProcessor;
+    private sendFrameToHandlers;
+    private sendFrameToSDC;
+    private registerFrameHandler;
+    private unregisterFrameHandler;
+    private onVisibilityChange;
+    private onWorkerMessage;
+    private subscribeToCameraManagerEvents;
+    private reportCameraProperties;
+    private onCameraAccessError;
+    private update;
+    private updateContext;
+    private getViewInfo;
+    private getMirrorAxisForFrameSource;
+    private addComponent;
+    private subscribeToWorkerMessages;
+    private unsubscribeToWorkerMessages;
+    private hasEnabledMode;
+    private isFeatureSupported;
+}
+
+/**
+ * MESSAGES (ACTIONS) SENT TO THE WORKER
+ */
+type DataCaptureActionMessageKey = "createContext" | "deleteFrameData" | "dispose" | "documentVisibility" | "extractCentaurusLicense" | "flushAnalytics" | "isFeatureSupported" | "loadLibrary" | "onTap" | "processFrame" | "reportCameraProperties" | "requestFrameData" | "setFrameSource" | "setLogLevel" | "updateContext" | "hintPresenterV2update" | "getViewfinderInfo" | "getOpenSourceSoftwareLicenseInfo";
+interface ExtractCentaurusLicenseResponse {
+    centaurus: {
+        licenseKey: string;
+    };
+}
+interface RequestFrameDataResponse {
+    data: Uint8ClampedArray | null;
+}
+interface IsFeatureSupportedResponse {
+    supported: boolean;
+}
+interface GetViewfinderInfo {
+    isDisplayingViewfinder: boolean;
+    rect: RectJSON;
+}
+interface GetOpenSourceSoftwareLicenseInfoResponse {
+    licenseText: string;
+}
+type WorkerResponse<C> = C extends "processFrame" ? ProcessFrameParameters : C extends "extractCentaurusLicense" ? ExtractCentaurusLicenseResponse : C extends "requestFrameData" ? RequestFrameDataResponse : C extends "isFeatureSupported" ? IsFeatureSupportedResponse : C extends "getViewfinderInfo" ? GetViewfinderInfo : C extends "getOpenSourceSoftwareLicenseInfo" ? GetOpenSourceSoftwareLicenseInfoResponse : undefined;
+interface DataCaptureActionMessage {
+    command: DataCaptureActionMessageKey;
+    id: number;
+}
+type LoadLibraryDataCaptureAction = DataCaptureActionMessage & LoadLibraryParameters & {
+    command: "loadLibrary";
+};
+type CreateContextDataCaptureAction = CreateContextParameters & DataCaptureActionMessage & {
+    command: "createContext";
+};
+type SetFrameSourceDataCaptureAction = DataCaptureActionMessage & SetFrameSourceParameters & {
+    command: "setFrameSource";
+};
+type ProcessFrameDataCaptureAction = DataCaptureActionMessage & ProcessFrameParameters & {
+    command: "processFrame";
+};
+type RequestFrameDataDataCaptureAction = DataCaptureActionMessage & {
+    command: "requestFrameData";
+    frameId: number;
+};
+type DeleteFrameDataDataCaptureAction = DataCaptureActionMessage & {
+    command: "deleteFrameData";
+    frameId: number;
+};
+type VisibilityChangeAction = DataCaptureActionMessage & {
+    command: "documentVisibility";
+    state: DocumentVisibilityState;
+};
+type IsFeatureSupportedAction = DataCaptureActionMessage & {
+    command: "isFeatureSupported";
+    feature: LicensedFeature;
+};
+type UpdateContextDataCaptureAction = DataCaptureActionMessage & {
+    command: "updateContext";
+    context: DataCaptureContextJSON;
+    view: UpdateContextParameters["view"];
+};
+type DisposeDataCaptureAction = DataCaptureActionMessage & {
+    command: "dispose";
+};
+type FlushAnalyticsDataCaptureAction = DataCaptureActionMessage & {
+    command: "flushAnalytics";
+};
+type ReportCameraPropertiesDataCaptureAction = DataCaptureActionMessage & ReportCameraPropertiesParameters & {
+    command: "reportCameraProperties";
+};
+type SetLogLevelDataCaptureAction = DataCaptureActionMessage & {
+    command: "setLogLevel";
+    level: Logger.Level;
+};
+type ExtractCentaurusLicenseDataCaptureAction = DataCaptureActionMessage & {
+    command: "extractCentaurusLicense";
+    licenseKey: string;
+};
+type OnTapAction = DataCaptureActionMessage & {
+    command: "onTap";
+    point: PointJSON;
+};
+type HintPresenterV2updateAction = DataCaptureActionMessage & {
+    command: "hintPresenterV2update";
+};
+type GetViewfinderInfoAction = DataCaptureActionMessage & {
+    command: "getViewfinderInfo";
+};
+type GetOpenSourceSoftwareLicenseInfoAction = DataCaptureActionMessage & {
+    command: "getOpenSourceSoftwareLicenseInfo";
+};
+type AnyDataCaptureActionMessage = CreateContextDataCaptureAction | DeleteFrameDataDataCaptureAction | DisposeDataCaptureAction | ExtractCentaurusLicenseDataCaptureAction | FlushAnalyticsDataCaptureAction | IsFeatureSupportedAction | LoadLibraryDataCaptureAction | OnTapAction | ProcessFrameDataCaptureAction | ReportCameraPropertiesDataCaptureAction | RequestFrameDataDataCaptureAction | SetFrameSourceDataCaptureAction | SetLogLevelDataCaptureAction | UpdateContextDataCaptureAction | VisibilityChangeAction | HintPresenterV2updateAction | GetViewfinderInfoAction | GetOpenSourceSoftwareLicenseInfoAction;
+/**
+ * MESSAGES EMITTED BY THE WORKER
+ */
+type DataCaptureCallbackMessageKeys = "contextDidChangeStatus" | "didStartObservingContext" | "draw" | "hideHint" | "isFeatureSupported" | "loadLibraryProgress" | "performanceMetricsReport" | "showHint" | "successFeedback" | "updateHint" | "workerTaskId" | "onFrameProcessingStarted" | "onFrameProcessingFinished" | "onFrameSkipped" | "showToast" | "hideToast" | "showGuidance" | "hideGuidance" | "startUpdateTimer" | "stopUpdateTimer" | "setViewfinderRect";
+interface BaseDataCaptureCallbackMessage {
+    type: DataCaptureCallbackMessageKeys;
+}
+interface LoadLibraryProgressMessage {
+    type: "loadLibraryProgress";
+    payload: ProgressInfo;
+}
+interface ConsoleWorkerMessage {
+    type: "console";
+    payload: string;
+}
+interface WorkerTaskIdWorkerMessage extends BaseDataCaptureCallbackMessage {
+    type: "workerTaskId";
+    command: string;
+    id: number;
+    error?: unknown;
+    payload?: unknown;
+}
+type DrawWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "draw";
+    payload: Uint8Array;
+};
+type DidChangeStatusWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "contextDidChangeStatus";
+    payload: ContextStatusJSON;
+};
+type StartObservingContextWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "didStartObservingContext";
+};
+type SuccessFeedbackWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "successFeedback";
+};
+type ShowHintWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "showHint";
+    payload: {
+        text: string;
+        style: HintStyle;
+    };
+};
+type UpdateHintWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "updateHint";
+    payload: {
+        style: HintStyle;
+    };
+};
+type IsFeatureSupportedMessage = BaseDataCaptureCallbackMessage & {
+    type: "isFeatureSupported";
+    payload: {
+        [key in LicensedFeature]: boolean;
+    };
+};
+type HideHintWorkerMessage = BaseDataCaptureCallbackMessage & {
+    type: "hideHint";
+    payload: Record<string, never>;
+};
+type PerformanceMetricsReportMessage = BaseDataCaptureCallbackMessage & {
+    type: "performanceMetricsReport";
+    payload: PerformanceMetrics;
+};
+type DidTapTrackedBarcode = BaseDataCaptureCallbackMessage & {
+    type: "didTapTrackedBarcode";
+    payload: any;
+};
+type OnFrameProcessingStartedMessage = BaseDataCaptureCallbackMessage & {
+    type: "onFrameProcessingStarted";
+};
+type OnFrameProcessingFinishedMessage = BaseDataCaptureCallbackMessage & {
+    type: "onFrameProcessingFinished";
+};
+type OnFrameSkippedMessage = BaseDataCaptureCallbackMessage & {
+    type: "onFrameSkipped";
+};
+type ShowToastMessage = BaseDataCaptureCallbackMessage & {
+    type: "showToast";
+    payload: GenericHint;
+};
+type HideToastMessage = BaseDataCaptureCallbackMessage & {
+    type: "hideToast";
+    payload: GenericHint;
+};
+type ShowGuidanceMessage = BaseDataCaptureCallbackMessage & {
+    type: "showGuidance";
+    payload: GenericHint;
+};
+type HideGuidanceMessage = BaseDataCaptureCallbackMessage & {
+    type: "hideGuidance";
+    payload: GenericHint;
+};
+type StartUpdateTimerMessage = BaseDataCaptureCallbackMessage & {
+    type: "startUpdateTimer";
+    payload: {
+        duration: {
+            unit: "ms";
+            value: number;
+        };
+    };
+};
+type StopUpdateTimerMessage = BaseDataCaptureCallbackMessage & {
+    type: "stopUpdateTimer";
+};
+type DataCaptureCallbackMessage = ConsoleWorkerMessage | DidChangeStatusWorkerMessage | DrawWorkerMessage | HideHintWorkerMessage | IsFeatureSupportedMessage | LoadLibraryProgressMessage | PerformanceMetricsReportMessage | ShowHintWorkerMessage | StartObservingContextWorkerMessage | SuccessFeedbackWorkerMessage | UpdateHintWorkerMessage | WorkerTaskIdWorkerMessage | OnFrameProcessingStartedMessage | OnFrameProcessingFinishedMessage | OnFrameSkippedMessage | ShowToastMessage | HideToastMessage | ShowGuidanceMessage | HideGuidanceMessage | StartUpdateTimerMessage | StopUpdateTimerMessage;
+/**
+ * OTHERS
+ */
+type PayloadForCommand<A, C> = A extends {
+    command: C;
+} ? A : never;
+interface DataCaptureWorker extends Omit<Worker, "postMessage"> {
+    onmessage: ((this: Worker, event_: MessageEvent & {
+        data: unknown;
+    }) => void) | null;
+    postMessage: <C extends AnyDataCaptureActionMessage["command"]>(message: PayloadForCommand<AnyDataCaptureActionMessage, C>, transfer?: Transferable[]) => void;
+}
+interface EmscriptenClassHandle<Self = EmscriptenClassHandle<unknown>> {
+    clone: () => Self;
+    delete: () => void;
+    isDeleted: () => boolean;
+    deleteLater: () => void;
+    isAliasOf: () => Self;
+}
+interface DataCaptureContext extends EmscriptenClassHandle {
+    setCameraProperties: (deviceId: string, isFrontFacing: boolean, hasAutofocus: boolean) => void;
+    addListener: (function_: unknown) => void;
+    addFrameListener: (listener: unknown) => void;
+    dispose: () => void;
+    setFrameSource: (source: EmscriptenClassHandle) => void;
+    flushAnalytics: () => void;
+    isFeatureSupported: (feature: LicensedFeature) => boolean;
+}
+interface DataCaptureImageBufferFrameSource extends EmscriptenClassHandle {
+    outputFrame: (address: number, width: number, height: number, format: unknown) => void;
+}
+interface GestureListener extends EmscriptenClassHandle<GestureListener> {
+    onTap(point: string): void;
+}
+interface GestureRecognizer extends EmscriptenClassHandle {
+    setGestureListener(gestureListener: GestureListener, flags: number): void;
+}
+interface DataCaptureView extends EmscriptenClassHandle {
+    setViewSize: (w: number, h: number, orientation: Orientation) => void;
+    setNeedsRedrawDelegate: (delegate: unknown) => void;
+    draw: () => void;
+    getDrawCommands: () => Uint8Array;
+    isViewRefreshHandlerSet: boolean;
+    hintPresenterInitialized: () => boolean;
+    setHintPresenter: (hintPresenter: unknown) => void;
+    setHintPresenterV2: (hintPresenterV2: HintPresenterV2) => void;
+    setGestureRecognizer: (recognizer: GestureRecognizer) => void;
+    isDisplayingViewfinder: () => boolean;
+    getViewfinderRect: () => string;
+    addOverlay: (overlay: EmscriptenClassHandle) => void;
+    removeOverlay: (overlay: EmscriptenClassHandle) => void;
+}
+interface JSONParseable {
+    toJson: () => string;
+}
+interface DataCaptureContextDeserializerResult extends EmscriptenClassHandle {
+    getContext: () => DataCaptureContext;
+    getView: () => DataCaptureView | undefined;
+}
+interface DataCaptureContextDeserializer extends EmscriptenClassHandle {
+    contextFromJson: (json: string) => DataCaptureContextDeserializerResult | null;
+    updateContextFromJson: (context: DataCaptureContext, view: DataCaptureView | undefined, json: string) => DataCaptureContextDeserializerResult | null;
+    getLastError: () => string;
+}
+interface CaptureModeDeserializerInstance extends EmscriptenClassHandle {
+    setListener: (listener: unknown) => void;
+}
+interface ModuleMirrorAxis {
+    None: unknown;
+    X: unknown;
+    Y: unknown;
+}
+interface Vector<T = unknown> {
+    push_back: (element: unknown) => void;
+    get: (index: number) => T;
+    size: () => number;
+}
+interface WasmFrameData {
+    getFrameData: () => Uint8ClampedArray;
+    getWidth: () => number;
+    getHeight: () => number;
+    getMirrorAxis: () => unknown;
+    getOrientation: () => unknown;
+}
+declare enum HintFont {
+    Body = "body",
+    Footnote = "footnote"
+}
+declare enum HintTextAlignment {
+    Start = "start",
+    Center = "center",
+    End = "end"
+}
+declare enum HintWidth {
+    Normal = "normal",
+    Wider = "wider",
+    FitText = "fitText"
+}
+declare enum HintHeight {
+    Normal = "normal",
+    Taller = "taller"
+}
+declare enum HintCornerStyle {
+    Square = "square",
+    Rounded = "rounded"
+}
+declare enum HintIcon {
+    None = "none",
+    Check = "check",
+    ExclamationMark = "exclamationMark"
+}
+declare enum HintAnchor {
+    Top = "top",
+    AboveViewFinder = "aboveViewFinder",
+    BelowViewFinder = "belowViewFinder"
+}
+interface HintStyle {
+    textColor: string;
+    textAlignment: HintTextAlignment;
+    backgroundColor: string;
+    hintIcon: HintIcon;
+    isAnimatedToView: boolean;
+    hintAnchor: HintAnchor;
+    hintAnchorOffset: number;
+    horizontalMargin: number;
+    maxWidthFraction: number;
+    textSize: number;
+    textWeight: number;
+    lineHeight: number;
+    iconColor: string;
+    maxLines: number;
+    cornerRadius: number;
+    fitToText: boolean;
+    /**
+     * Will be removed after Id Capture migrates to HintPresenter v2
+     * @deprecated
+     */
+    anchor: Anchor;
+    /**
+     * @deprecated
+     */
+    verticalOffsetRatio: number;
+    /**
+     * @deprecated
+     */
+    font: HintFont;
+    /**
+     * @deprecated
+     */
+    hintWidth: HintWidth;
+    /**
+     * @deprecated
+     */
+    hintHeight: HintHeight;
+    /**
+     * @deprecated
+     */
+    hintCornerStyle: HintCornerStyle;
+}
+declare enum GuidanceHintAnchor {
+    AboveViewFinder = "aboveViewFinder",
+    BelowViewFinder = "belowViewFinder"
+}
+declare enum GuidanceHintStyle {
+    BlackOnWhite = "blackOnWhite",
+    WhiteOnBlack = "whiteOnBlack",
+    Transparent = "transparent"
+}
+interface GuidanceHint {
+    text: string;
+    guidanceHintStyle: GuidanceHintStyle;
+    guidanceHintAnchor: GuidanceHintAnchor;
+    hintStyle?: HintStyle;
+    moveCloserAnimation?: boolean;
+}
+declare enum ToastHintStyle {
+    Success = "success",
+    Error = "error",
+    Warning = "warning",
+    Info = "info",
+    Notification = "notification"
+}
+interface ToastHint {
+    text: string;
+    tag: string;
+    toastHintStyle: ToastHintStyle;
+    hintStyle?: HintStyle;
+}
+interface GenericHint {
+    text: string;
+    tag?: string;
+    hintStyle: Omit<HintStyle, "anchor" | "verticalOffsetRatio" | "font" | "hintWidth" | "hintHeight" | "hintCornerStyle">;
+}
+interface PerformanceMetrics {
+    processedFramesCount: number;
+    redrawRequestsCount: number;
+    actualRedrawsCount: number;
+    frameDataPoolSize: number;
+}
+declare enum LicensedFeature {
+    Ocr = 0,
+    HideLogo = 1,
+    ShowTestLicenseMessage = 2,
+    AugmentedReality = 5,
+    ActivityPingStatsAddon = 8,
+    ActivityPing = 9,
+    Registration = 10,
+    Parser = 11,
+    BarcodeCapture = 14,
+    Analytics = 17,
+    AnalyticsBatchMode = 18,
+    AnalyticsScanContent = 19,
+    AnalyticsOnlineVerification = 20,
+    SparkScan = 21,
+    AamvaIdBarcodeVerification = 22,
+    MappingForTracking = 23,
+    BarcodeFind = 24,
+    MandatoryRegistration = 25,
+    FeatureTracking = 26,
+    IdCaptureViz = 27,
+    IdCaptureMrz = 28,
+    IdCaptureBarcode = 29,
+    BarcodeSelectionAimToScan = 30,
+    BarcodeSelectionTapToScan = 31,
+    BarcodeCount = 32,
+    BarcodePick = 33,
+    IdVerificationDataComparison = 34,
+    SmartLabelBarcode = 35,
+    SmartLabelText = 36,
+    VoidedIdDetection = 37,
+    BarcodeArFull = 38
+}
+interface HintPresenterV2 extends EmscriptenClassHandle {
+    showToast: (toastHint: string) => void;
+    hideToast: (tag: string) => void;
+    hideAllToasts: () => void;
+    showGuidance: (guidanceHint: string) => void;
+    hideCurrentGuidance: () => void;
+    update: () => void;
+}
+interface PlatformHintPresenter extends EmscriptenClassHandle {
+    setHintPresenter(presenter: HintPresenterV2): void;
+    showToast(toast: string): void;
+    hideToast(toast: string): void;
+    showGuidance(guidanceHint: string): void;
+    hideGuidance(guidanceHint: string): void;
+    startUpdateTimer(intervalMs: number): void;
+    stopUpdateTimer(): void;
+}
+interface Module extends EmscriptenModule {
+    callMain: () => void;
+    canvas: OffscreenCanvas | undefined;
+    PThread?: Record<number | string | symbol, unknown>;
+    mainScriptUrlOrBlob: string;
+    DataCaptureContextDeserializer: new (fsFolderPath: string, deviceId: string, deviceModel: string, domain: string, parentDomain: string, modeDeserializer: Vector, delayedRegistration: boolean, highEndBlurryRecognition: boolean, resourcePath: string) => DataCaptureContextDeserializer;
+    DataCaptureContextListener: {
+        extend: (target: "DataCaptureContextListener", parameters: {
+            didChangeStatus: (context: DataCaptureContext, contextStatus: {
+                toJson: () => string;
+            }) => void;
+            didStartObservingContext: (context: DataCaptureContext) => void;
+        }) => new () => EmscriptenClassHandle;
+    };
+    DataCaptureContextFrameListener: {
+        extend: (target: "DataCaptureContextFrameListener", parameters: {
+            onObservationStarted: (context: DataCaptureContext) => void;
+            onObservationStopped: (context: DataCaptureContext) => void;
+            onFrameProcessingStarted: (context: DataCaptureContext, frameData: WasmFrameData) => void;
+            onFrameProcessingFinished: (context: DataCaptureContext, frameData: WasmFrameData) => void;
+            onFrameSkipped: (context: DataCaptureContext, frameData: WasmFrameData) => void;
+        }) => new () => EmscriptenClassHandle;
+    };
+    HintPresenter: {
+        extend: (target: "HintPresenter", parameters: {
+            showHint: (hint: string, style: string) => void;
+            updateHint: (style: string) => void;
+            hideHint: () => void;
+        }) => new () => EmscriptenClassHandle;
+    };
+    PlatformHintPresenter: {
+        extend: (target: "PlatformHintPresenter", parameters: {
+            setHintPresenter(presenter: HintPresenterV2): void;
+            showToast(toastHint: string): void;
+            hideToast(toastHint: string): void;
+            showGuidance(guidanceHint: string): void;
+            hideGuidance(guidanceHint: string): void;
+            startUpdateTimer(intervalMs: number): void;
+            stopUpdateTimer(): void;
+        }) => new () => PlatformHintPresenter;
+    };
+    HintPresenterV2: new (platformHintPresenter: PlatformHintPresenter) => HintPresenterV2;
+    ImageBufferFrameSource: new (mirroredAxis: unknown, isCameraFrameSource: boolean, orientation?: number) => DataCaptureImageBufferFrameSource;
+    ImageBufferFormat: {
+        Grayscale8: unknown;
+        Rgb888: unknown;
+        Rgba8888: unknown;
+    };
+    Axis: ModuleMirrorAxis;
+    NeedsRedrawDelegate: {
+        extend: (target: "NeedsRedrawDelegate", parameters: {
+            setNeedsRedrawIn: (inMs: number) => void;
+        }) => new () => EmscriptenClassHandle;
+    };
+    GestureRecognizer: {
+        extend: (target: "GestureRecognizer", parameters: {
+            setGestureListener(gestureListener: GestureListener, flags: number): void;
+        }) => new () => GestureRecognizer;
+    };
+    VectorDataCaptureModeDeserializer: new () => Vector;
+    allocateUint8Array: (length: number) => number;
+    deleteUint8Array: (adress: number) => void;
+    DataDecoding: {
+        extend: (target: "DataDecoding", options: {
+            decode: (rawData: ArrayBuffer, encodingRanges: string) => string;
+        }) => new () => EmscriptenClassHandle;
+    };
+    setDataDecoding: (decoder: unknown) => void;
+    LicenseUtils: {
+        getBlinkIdLicenseKey: (scanditLicense: string) => string;
+    };
+    Feedback: {
+        extend: (target: "Feedback", parameters: {
+            emit: () => void;
+        }) => new () => EmscriptenClassHandle;
+    };
+    dispose: () => void;
+    LicenseFeature: LicensedFeature;
+    addBarcodeFindToContext: (context: DataCaptureContext, mode: EmscriptenClassHandle) => void;
+    removeBarcodeFindFromContext: (context: DataCaptureContext, mode: EmscriptenClassHandle) => void;
+    addBarcodeFindBasicOverlayToView: (view: DataCaptureView, overlay: EmscriptenClassHandle) => void;
+    removeBarcodeFindBasicOverlayFromView: (view: DataCaptureView, overlay: EmscriptenClassHandle) => void;
+    OpenSourceSoftwareLicenseInfo: {
+        getLicenseText(): string;
+    };
+}
+type AugmentedWorker<M extends EmscriptenModule> = Worker & {
+    Module: M;
+    OffscreenCanvas: new (w: number, h: number) => OffscreenCanvas;
+};
+type EngineWorkerResponse<C extends DataCaptureActionMessageKey> = WorkerResponse<C> extends Promise<void> | void ? Promise<void> | void : {
+    payload: WorkerResponse<C>;
+    transferables?: Transferable[];
+};
+interface ModuleHandler<M extends Module> {
+    get: () => M;
+    set: (v: M) => void;
+}
+
+interface FrameData {
+    readonly width: number;
+    readonly height: number;
+    readonly isFrameSourceMirrored: boolean;
+    toBlob(type?: string, quality?: number): Promise<Blob | null>;
+    getData(): Promise<Uint8ClampedArray | null>;
+}
+type PrivateLoadableFrameData = Omit<FrameData, "getData" | "toBlob"> & {
+    frameId: number;
+};
+/**
+ * Adds some function to the passed frame data object to let the user load the frame data.
+ */
+declare function convertToPublicFrameData(loadableFrameData: PrivateLoadableFrameData, context: DataCaptureContext$1): FrameData;
+
+interface LoadLibraryParameters {
+    libraryLocation: string;
+    locationPath: string;
+    preloadEngine: boolean;
+    writableDataPathOverride?: string;
+    overrideSimdSupport: OverrideState;
+    overrideThreadsSupport: OverrideState;
+    verifyResponseHash: boolean;
+    onProgress?: (info: ProgressInfo) => void;
+    referredOrigin?: string;
+}
+interface CreateContextParameters {
+    context: DataCaptureContextJSON;
+    deviceId: string;
+    delayedRegistration: boolean;
+    highEndBlurryRecognition: boolean;
+    appName: string | null;
+    parentDomain: string;
+}
+interface UpdateContextParameters {
+    context: DataCaptureContextJSON;
+    view: {
+        width: number;
+        height: number;
+        visible: boolean;
+        orientation: Orientation;
+    } | null;
+}
+interface SetFrameSourceParameters {
+    mirrorAxis: PrivateMirrorAxis;
+    isCameraFrameSource: boolean;
+}
+type ProcessFrameParameters = FrameCapture;
+interface ReportCameraPropertiesParameters {
+    deviceId: string;
+    hasAutofocus: boolean;
+    isFrontFacing: boolean;
+}
+interface WorkerFunctions {
+    getOffscreenCanvas: () => OffscreenCanvas | undefined;
+    postMessage: (message: DataCaptureCallbackMessage, transfer?: Transferable[]) => void;
+}
+/**
+ * DataCaptureEngine is an abstraction of the engine, it is created by the engine worker
+ * and should be used as a singleton. It calls the underlying engine methods directly.
+ */
+declare class DataCaptureEngine<M extends Module> {
+    private static get3dPartyLicenseKeyMethodName;
+    context: DataCaptureContext;
+    lastUsedModuleMirrorAxis: unknown;
+    view: DataCaptureView | undefined;
+    hintPresenterV2: HintPresenterV2 | null;
+    protected readonly MAX_NUMBER_OF_IMAGES_IN_FRAME_DATA_POOL: number;
+    protected readonly moduleHandler: ModuleHandler<M>;
+    protected readonly redrawInterval: number;
+    protected readonly redrawRequests: number[];
+    protected readonly workerFunctions: WorkerFunctions;
+    protected _isDrawLoopRunning: boolean;
+    protected contextDeserializer: DataCaptureContextDeserializer | undefined;
+    protected frameDataPool: Map<number, Uint8ClampedArray>;
+    protected imageFrameSource?: DataCaptureImageBufferFrameSource;
+    protected lastFrameCounter: number;
+    protected libraryLoadingPromise: Promise<void> | undefined;
+    protected loopTimeoutId?: ReturnType<typeof setTimeout>;
+    protected resourcePath: string;
+    protected writableDataPath: string;
+    protected poorMansBenchmarkLogs: boolean;
+    protected parentDomain: string;
+    protected readonly writableDataPathPreload: string;
+    protected readonly writableDataPathStandard: string;
+    protected readonly resourceFilesSubfolder: string;
+    protected performanceMetricsReporterTimer: ReturnType<typeof setTimeout> | undefined;
+    protected performanceMetrics: PerformanceMetrics;
+    protected gestureRecognizer: GestureRecognizer | null;
+    private gestureListener;
+    private webPlatformHintPresenter;
+    constructor(moduleHandler: ModuleHandler<M>, workerFunctions: WorkerFunctions);
+    get Module(): M;
+    set isDrawLoopRunning(newValue: boolean);
+    get isDrawLoopRunning(): boolean;
+    convertToLoadableFrameData(frameData: WasmFrameData): PrivateLoadableFrameData;
+    createContext(createContextJSON: CreateContextParameters): EngineWorkerResponse<"createContext">;
+    onTap(point: PointJSON): void;
+    hintPresenterV2Update(): void;
+    startReportingPerformanceMetrics(): void;
+    reportPerformanceMetrics(): Promise<void>;
+    deleteFrameData(frameId: number): void;
+    dispose(): EngineWorkerResponse<"dispose">;
+    flushAnalytics(): void;
+    extractCentaurusLicense(scanditLicenseKey: string): EngineWorkerResponse<"extractCentaurusLicense">;
+    getModeDeserializers(): Vector;
+    loadLibrary(parameters: LoadLibraryParameters): EngineWorkerResponse<"loadLibrary">;
+    processFrame(parameters: ProcessFrameParameters): EngineWorkerResponse<"processFrame">;
+    reportCameraProperties(properties: ReportCameraPropertiesParameters): EngineWorkerResponse<"reportCameraProperties">;
+    requestFrameData(frameId: number): EngineWorkerResponse<"requestFrameData">;
+    scheduleRedraw(view: DataCaptureView, redrawInMs: number): void;
+    sendViewRefreshCommands(commands: Uint8Array): void;
+    setFrameSource(mirrorAxis: PrivateMirrorAxis, isCameraFrameSource: boolean): EngineWorkerResponse<"setFrameSource">;
+    /**
+     * The draw loop check at regular interval if any redraw request were made by the engine.
+     * If a redraw is necessary, it gathers and sends drawing commands to the main thread.
+     */
+    startDrawLoop(view: DataCaptureView): void;
+    updateContext(contextUpdateParameters: UpdateContextParameters): EngineWorkerResponse<"updateContext">;
+    onDocumentVisibilityChange(state: DocumentVisibilityState): void;
+    isFeatureSupported(feature: LicensedFeature): EngineWorkerResponse<"isFeatureSupported">;
+    getViewfinderInfo(): EngineWorkerResponse<"getViewfinderInfo">;
+    getOpenSourceSoftwareLicenseInfo(): EngineWorkerResponse<"getOpenSourceSoftwareLicenseInfo">;
+    protected getNextFrameId(): number;
+    protected getWasmDynamicLibraries(coreWasmURI: string): string[];
+    protected getWasmCoreExpectedHash(simdSupport: boolean, threadsSupport: boolean): string;
+    protected getWasmCoreFileName(simdSupport: boolean, threadsSupport: boolean): string;
+    protected getWasmMetadata(): Record<string, {
+        bytes: number;
+    }>;
+    protected getWasmSideModuleFileName(): string;
+    private _loadProgressCallback;
+    /**
+     * Redraw requests are scheduled at [now + redrawInMs], so when pushed they must be sorted
+     * in chronological order so that we can later easily check if we need to redraw by checking
+     * the first element.
+     * @param redrawInMs
+     */
+    private addRedrawRequest;
+    private contextDidChangeStatus;
+    private didStartObservingContext;
+    private mapMirrorAxisOnModule;
+    private setView;
+    private setViewRefreshHandler;
+    private setupDataDecoding;
+    private start;
+    private getWritableDataPath;
+    private setup;
+}
+
+declare enum MeteringMode {
+    CONTINUOUS = "continuous",
+    MANUAL = "manual",
+    NONE = "none",
+    SINGLE_SHOT = "single-shot"
+}
+declare enum CameraResolutionConstraint {
+    ULTRA_HD = 0,
+    FULL_HD = 1,
+    HD = 2,
+    SD = 3,
+    NONE = 4
+}
+interface ExtendedMediaTrackCapabilities extends MediaTrackCapabilities {
+    exposureCompensation?: DoubleRange;
+    exposureMode?: MeteringMode[];
+    exposureTime?: DoubleRange;
+    focusDistance?: DoubleRange;
+    focusMode?: MeteringMode[];
+    torch?: boolean;
+    zoom?: DoubleRange;
+}
+interface ExtendedMediaTrackConstraintSet extends MediaTrackConstraintSet {
+    exposureCompensation?: ConstrainDouble | number;
+    exposureMode?: MeteringMode;
+    exposureTime?: ConstrainDouble | number;
+    focusDistance?: ConstrainDouble | number;
+    focusMode?: MeteringMode;
+    torch?: boolean;
+    zoom?: ConstrainDouble | number;
+}
+interface GUI {
+    isCameraRecoveryVisible: () => boolean;
+    setCameraRecoveryVisible: (visible: boolean) => void;
+}
+interface FrameCapture {
+    colorType?: ColorType;
+    data: Uint8ClampedArray;
+    height: number;
+    width: number;
+}
+declare enum CameraManagerEvent {
+    CAMERA_PROPERTIES = "cameraProperties",
+    CAMERA_ACCESS_ERROR = "cameraAccessError"
+}
+type CameraManagerEventParameters<C> = C extends CameraManagerEvent.CAMERA_PROPERTIES ? ReportCameraPropertiesParameters : C extends CameraManagerEvent.CAMERA_ACCESS_ERROR ? any : never;
+/**
+ * A barcode picker utility class used to handle camera interaction.
+ */
+declare class CameraManager {
+    private static readonly autofocusIntervalMs;
+    private static readonly cameraAccessTimeoutMs;
+    private static readonly getCapabilitiesTimeoutMs;
+    private static readonly manualFocusWaitTimeoutMs;
+    private static readonly manualToAutofocusResumeTimeoutMs;
+    private static readonly noCameraErrorParameters;
+    private static readonly notReadableErrorParameters;
+    private static readonly videoMetadataCheckIntervalMs;
+    private static readonly videoMetadataCheckTimeoutMs;
+    private static MIRRORED_CLASS_NAME;
+    private static _instance;
+    activeCamera?: DeviceCamera$1;
+    activeCameraSettings?: CameraSettings;
+    canvas: HTMLCanvasElement;
+    gui: GUI;
+    selectedCamera?: DeviceCamera$1;
+    videoElement: HTMLVideoElement;
+    private readonly checkCameraVideoStreamAccessIfVisibleListener;
+    private readonly handleWebGLContextLostListener;
+    private readonly listeners;
+    private readonly mirrorImageOverrides;
+    private readonly postStreamInitializationListener;
+    private readonly triggerFatalError;
+    private readonly triggerManualFocusListener;
+    private readonly triggerZoomMoveListener;
+    private readonly triggerZoomStartListener;
+    private readonly videoResizeListener;
+    private readonly videoTrackEndedListener;
+    private readonly videoTrackMuteListener;
+    private _canvas2dContext;
+    private _canvasWebGLContext;
+    private _glFrameReaders;
+    private _frameReaderType;
+    private _mediaStream?;
+    private abortedCameraInitializationResolveCallback?;
+    private autofocusInterval;
+    private cameraAccessRejectCallback?;
+    private cameraAccessTimeout;
+    private cameraInitializationPromise?;
+    private cameraPosition;
+    private cameraSetupPromise?;
+    private getCapabilitiesTimeout;
+    private manualFocusWaitTimeout;
+    private manualToAutofocusResumeTimeout;
+    private mediaTrackCapabilities?;
+    private mediaTrackCapabilitiesPromise?;
+    private mediaTrackCapabilitiesPromiseResolver?;
+    private pinchToZoomDistance?;
+    private pinchToZoomEnabled;
+    private pinchToZoomInitialZoom;
+    private selectedCameraSettings?;
+    private tapToFocusEnabled;
+    private torchEnabled;
+    private torchToggleEnabled;
+    private videoMetadataCheckInterval;
+    private isWebGLSupported;
+    constructor();
+    get mediaStream(): MediaStream | undefined;
+    set mediaStream(stream: MediaStream | undefined);
+    private get canvas2dContext();
+    private get canvasWebGLContext();
+    static instance(): CameraManager;
+    recycle(pixelsData: Uint8ClampedArray): void;
+    getCurrentFrame(): FrameCapture | undefined;
+    requestVideoFrame(scheduledFunction: FrameRequestCallback | VideoFrameRequestCallback): number;
+    cancelVideoFrame(id: number): void;
+    addListener<E extends CameraManagerEvent>(event: CameraManagerEvent, listener: (details: CameraManagerEventParameters<E>) => void): void;
+    applyCameraSettings(cameraSettings?: CameraSettings): Promise<void>;
+    captureImage(): FrameCapture | null;
+    initializeCameraWithSettings(camera?: DeviceCamera$1, cameraSettings?: CameraSettings): Promise<void>;
+    isMirrorImageEnabled(): boolean;
+    isPinchToZoomEnabled(): boolean;
+    isTapToFocusEnabled(): boolean;
+    isTorchAvailable(): Promise<boolean>;
+    playVideo(): Promise<void>;
+    reinitializeCamera(): Promise<void>;
+    removeListener<E extends CameraManagerEvent>(event: CameraManagerEvent, listenerToRemove?: (details: CameraManagerEventParameters<E>) => void): void;
+    setCameraPosition(cameraPosition: CameraPosition): Promise<void>;
+    setExposure(exposure: {
+        compensation?: number;
+        time?: number;
+    }): Promise<void>;
+    setFocus(manualLensPosition: number): Promise<void>;
+    setFrameRate(frameRate: {
+        min?: number;
+        max?: number;
+    }): Promise<void>;
+    setInitialCameraPosition(cameraPosition: CameraPosition): void;
+    setInteractionOptions(torchToggleEnabled: boolean, tapToFocusEnabled: boolean, pinchToZoomEnabled: boolean): void;
+    setMirrorImageEnabled(enabled: boolean, override: boolean): void;
+    setPinchToZoomEnabled(enabled: boolean): void;
+    setSelectedCamera(camera?: DeviceCamera$1): void;
+    setSelectedCameraSettings(cameraSettings?: CameraSettings): void;
+    setTapToFocusEnabled(enabled: boolean): void;
+    setTorchEnabled(enabled: boolean): Promise<void>;
+    setZoom(zoomFactor: number): Promise<void>;
+    setupCameras(): Promise<void>;
+    pauseStream(): void;
+    resumeStream(): void;
+    stopStream(cameraInitializationFailure?: boolean): Promise<void>;
+    stopVideoTracks(): void;
+    toggleTorch(): Promise<void>;
+    updateCanvasVideoImage(): void;
+    waitForCapabilities(): Promise<void>;
+    setFrameReaderType(type: ColorType): void;
+    allowPictureInPicture(allow: boolean): Promise<void>;
+    private accessAutoselectedCamera;
+    private accessInitialCamera;
+    /**
+     * When a context has been created for a canvas, it is not possible to get another one from another type.
+     * This function re-creates a new canvas based on the existing one.
+     */
+    private recreateCanvas;
+    private captureImageFor2dContext;
+    private areVideoAndWebGLSizeMismatching;
+    private captureImageForWebGLContext;
+    private checkCameraAccess;
+    private checkCameraVideoStreamAccessIfVisible;
+    private checkVideoMetadata;
+    private disablePinchToZoomListeners;
+    private disableTapToFocusListeners;
+    private emit;
+    private enablePinchToZoomListeners;
+    private enableTapToFocusListeners;
+    private getActiveCamera;
+    private getInitialCameraResolutionConstraint;
+    private handleCameraInitializationError;
+    private handleVideoResize;
+    private handleWebGLContextLost;
+    private initializeCameraAndCheckUpdatedSettings;
+    private initializeCameraForResolution;
+    private initializeStreamForResolution;
+    private isVideoAndContextStateValid;
+    private postStreamInitialization;
+    private recoverStreamIfNeeded;
+    private reportCameraProperties;
+    private setCameraAccessTimeout;
+    private setupAutofocus;
+    private setupCameraStreamVideo;
+    private setupCamerasAndStream;
+    private storeStreamCapabilities;
+    private triggerAutoFocus;
+    private triggerFocusMode;
+    private triggerManualFocus;
+    private triggerManualFocusForContinuous;
+    private triggerManualFocusForSingleShot;
+    private triggerZoomMove;
+    private triggerZoomStart;
+    private updateActiveCameraCurrentResolution;
+    private updateStreamForResolution;
+    private videoTrackEndedRecovery;
+    private videoTrackMuteRecovery;
+}
+
+interface CameraJSON extends FrameSourceJSON {
+    type: "camera";
+    position: CameraPosition;
+    settings: CameraSettingsJSON | Record<string, never>;
+    desiredState: FrameSourceState;
+    desiredTorchState: TorchState;
+}
+interface VideoFrameResolution {
+    readonly width: number;
+    readonly height: number;
+}
+declare class Camera implements FrameSource, Serializable<CameraJSON> {
+    readonly label: string;
+    deviceId: string;
+    readonly position: CameraPosition;
+    private _currentResolution?;
+    private readonly cameraManager;
+    private readonly type;
+    private readonly webGLContextLostListener;
+    private _currentState;
+    private _settings;
+    private _desiredTorchState;
+    private _desiredState;
+    private readonly listeners;
+    private _context;
+    private _desiredMirrorImageEnabled?;
+    private _lastCaptureRequestAnimationFrame?;
+    private _lastCanvasVideoPreviewAnimationFrame?;
+    private _isAndroidWebView?;
+    private readonly stateTransitionStrategyMap;
+    private currentTransitionStrategyPromise?;
+    constructor(manager?: CameraManager);
+    static get default(): Camera;
+    get desiredState(): FrameSourceState;
+    get settings(): CameraSettings;
+    get currentResolution(): VideoFrameResolution | null;
+    private get context();
+    private set context(value);
+    private get currentState();
+    static atPosition(cameraPosition: CameraPosition): Camera | null;
+    static fromDeviceCamera(deviceCamera: DeviceCamera): Camera;
+    switchToDesiredState(state: FrameSourceState): Promise<void>;
+    getDesiredTorchState(): TorchState;
+    setDesiredTorchState(desiredTorchState: TorchState): Promise<void>;
+    isTorchAvailable(): Promise<boolean>;
+    addListener(listener: FrameSourceListener | null): void;
+    removeListener(listener: FrameSourceListener | null): void;
+    applySettings(settings: CameraSettings): Promise<void>;
+    toJSONObject(): CameraJSON;
+    getMirrorImageEnabled(): boolean;
+    setMirrorImageEnabled(enabled: boolean): Promise<void>;
+    getCurrentState(): FrameSourceState;
+    private setCurrentState;
+    /**
+     * Starts camera according to the given position. If a deviceId is set, pre-select the corresponding camera.
+     * The function returns as soon as the camera has started successfully and is active. The label and
+     * position properties reflect then the values found in the accessed stream.
+     */
+    private setupCamera;
+    private notifyContext;
+    private notifyListeners;
+    private updateCanvasVideoImage;
+    private captureAndSend;
+    /**
+     * Capture images from the video stream and send them to the context. If no context is set, the function will
+     * stop itself until called again. While no enabled mode is present in the context, the function will schedule itself
+     * again indefinitely without doing anything else.
+     */
+    private startSendingCapturesToWorker;
+    private stopSendingCapturesToWorker;
+    private transitionFromStateOffToOn;
+    private transitionFromStateOffToStandby;
+    private transitionFromStateOnToOff;
+    private transitionFromStateOnToStandby;
+    private transitionFromStateStandbyToOff;
+    private transitionFromStateStandbyToOn;
+    private isAndroidWebView;
+    private isZoomAvailable;
+}
+
+export { type ModuleHandler as $, type PrivateFrameHandler as A, DataCaptureContext$1 as B, CameraPosition as C, DataCaptureLoader as D, type DataCaptureContextListener as E, FocusGestureStrategy as F, type ContextStatusJSON as G, ContextStatus as H, PrivateMirrorAxis as I, type DataCaptureOverlay as J, type DataCaptureViewListener as K, type DataCaptureViewJSON as L, DataCaptureView$1 as M, type FrameData as N, type PrivateLoadableFrameData as O, type PrivateChangeSet as P, convertToPublicFrameData as Q, type DataCaptureLoaderOptions as R, type PerformanceMetrics as S, TorchState as T, DataCaptureEngine as U, VideoResolution as V, type Module as W, type GenericHint as X, type DataCaptureCallbackMessage as Y, type AnyDataCaptureActionMessage as Z, type AugmentedWorker as _, type FrameSource as a, HintIcon as a$, type DataCaptureActionMessageKey as a0, type EngineWorkerResponse as a1, type ExtractCentaurusLicenseResponse as a2, type RequestFrameDataResponse as a3, type IsFeatureSupportedResponse as a4, type GetViewfinderInfo as a5, type GetOpenSourceSoftwareLicenseInfoResponse as a6, type WorkerResponse as a7, type LoadLibraryDataCaptureAction as a8, type CreateContextDataCaptureAction as a9, type OnFrameSkippedMessage as aA, type ShowToastMessage as aB, type HideToastMessage as aC, type ShowGuidanceMessage as aD, type HideGuidanceMessage as aE, type StartUpdateTimerMessage as aF, type StopUpdateTimerMessage as aG, type PayloadForCommand as aH, type DataCaptureWorker as aI, type EmscriptenClassHandle as aJ, type DataCaptureContext as aK, type DataCaptureImageBufferFrameSource as aL, type GestureListener as aM, type GestureRecognizer as aN, type DataCaptureView as aO, type JSONParseable as aP, type DataCaptureContextDeserializerResult as aQ, type DataCaptureContextDeserializer as aR, type CaptureModeDeserializerInstance as aS, type ModuleMirrorAxis as aT, type Vector as aU, type WasmFrameData as aV, HintFont as aW, HintTextAlignment as aX, HintWidth as aY, HintHeight as aZ, HintCornerStyle as a_, type SetFrameSourceDataCaptureAction as aa, type ProcessFrameDataCaptureAction as ab, type RequestFrameDataDataCaptureAction as ac, type DeleteFrameDataDataCaptureAction as ad, type VisibilityChangeAction as ae, type IsFeatureSupportedAction as af, type UpdateContextDataCaptureAction as ag, type DisposeDataCaptureAction as ah, type FlushAnalyticsDataCaptureAction as ai, type ReportCameraPropertiesDataCaptureAction as aj, type SetLogLevelDataCaptureAction as ak, type ExtractCentaurusLicenseDataCaptureAction as al, type OnTapAction as am, type HintPresenterV2updateAction as an, type GetViewfinderInfoAction as ao, type GetOpenSourceSoftwareLicenseInfoAction as ap, type DataCaptureCallbackMessageKeys as aq, type SuccessFeedbackWorkerMessage as ar, type ShowHintWorkerMessage as as, type UpdateHintWorkerMessage as at, type IsFeatureSupportedMessage as au, type HideHintWorkerMessage as av, type PerformanceMetricsReportMessage as aw, type DidTapTrackedBarcode as ax, type OnFrameProcessingStartedMessage as ay, type OnFrameProcessingFinishedMessage as az, FrameSourceState as b, HintAnchor as b0, type HintStyle as b1, GuidanceHintAnchor as b2, GuidanceHintStyle as b3, type GuidanceHint as b4, ToastHintStyle as b5, type ToastHint as b6, LicensedFeature as b7, type HintPresenterV2 as b8, type PlatformHintPresenter as b9, type LoadLibraryParameters as ba, type CreateContextParameters as bb, type UpdateContextParameters as bc, type SetFrameSourceParameters as bd, type ProcessFrameParameters as be, type ReportCameraPropertiesParameters as bf, type WorkerFunctions as bg, FrameReaderAbstract as bh, ColorType as bi, type FrameCapture as bj, FrameReader as bk, CameraPosition$1 as bl, CameraResolutionConstraint$1 as bm, AspectRatio as bn, type DeviceCamera$1 as bo, CameraAccess$1 as bp, MeteringMode as bq, CameraResolutionConstraint as br, type ExtendedMediaTrackCapabilities as bs, type ExtendedMediaTrackConstraintSet as bt, type GUI as bu, CameraManagerEvent as bv, type CameraManagerEventParameters as bw, CameraManager as bx, type FrameSourceListener as c, type FrameSourceJSON as d, type CameraJSON as e, type VideoFrameResolution as f, Camera as g, type CameraSettingsJSONBase as h, type CameraSettingsFromJSON as i, type CameraSettingsJSON as j, isCameraFrameSource as k, CameraSettings as l, CameraAccess as m, type DeviceCamera as n, type Change as o, type PrivateDataCaptureMode as p, type DataCaptureMode as q, type DataCaptureModeJSON as r, type PrivateDataCaptureComponent as s, type DataCaptureComponentJSON as t, type DataCaptureComponent as u, type PrivateDataCaptureContextOptions as v, type PrivateDataCaptureContext as w, type DataCaptureContextCreationOptions as x, type DataCaptureContextJSON as y, type PrivateFrameHandlerResponse as z };