@microblink/capture 1.0.8 → 1.1.0

package/types/index.d.cts

@@ -1,12 +1,1115 @@
-/**
- * Copyright (c) 2023 Microblink Ltd. All rights reserved.
- *
- * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
- * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
- * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
- * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
- * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
- * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
- */
-export * from "capture-main";
-export * from "capture-ui";
+/// <reference types="emscripten" />
+
+import { MountableElement } from 'solid-js/web';
+import { SetStoreFunction } from 'solid-js/store';
+
+export declare class Analyzer extends EmbindObject {
+    /**
+     * Analyses a single image and returns either `FrameAnalysisResult` or `FrameAnalysisError`.
+     * Each captured image is stored as a candidate for the best frame.
+     */
+    analyze(image: ImageData): FrameAnalysisResult | FrameAnalysisError;
+    /**
+     * Returns the analyzer result.
+     */
+    getResult: () => AnalyzerResult;
+    /**
+     * Returns the analyzer settings.
+     */
+    getSettings: () => AnalyzerSettings;
+    /**
+     * Updates the analyzer settings.
+     */
+    updateSettings: (settings: AnalyzerSettings) => void;
+    /** Resets the currently active capturing process. */
+    reset: () => void;
+    /**
+     * Attempts to finish the side capture early.
+     *
+     * If there aren't enough captured frames, the method returns `false` and
+     * further `Analyzer.analyze` calls are required.
+     *
+     * Otherwise, the method returns `true` and the `Analyzer` uses the best frame
+     * candidate to finish the side capture and either finish the capture process
+     * or continue to the next side.
+     *
+     * @returns `true` if there are enough captured frames to finish the capture
+     * process and `getResult` can be called, `false` otherwise.
+     */
+    finishSideCapture: () => boolean;
+}
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+/**
+ * The result returned from `Analyzer.getResult`
+ */
+export declare type AnalyzerResult = {
+    /** Result of the first side capture */
+    firstCapture?: SideCaptureResult;
+    /** Result of the second side capture */
+    secondCapture?: SideCaptureResult;
+    /** Document group */
+    documentGroup: DocumentGroup;
+    /** Completeness status of the capture process */
+    completenessStatus: CompletenessStatus;
+};
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+/**
+ * Settings for the analyzer.
+ */
+export declare type AnalyzerSettings = {
+    /**
+     * Whether to capture a single side or capture both sides
+     * of a document with automatic side detection.
+     */
+    captureSingleSide: boolean;
+    /**
+     * Whether to return an image of a cropped and perspective-corrected document.
+     */
+    returnTransformedDocumentImage: boolean;
+    /**
+     * Configures the capture strategy used to select the best frame.
+     *
+     * The following values are possible:
+     *
+     * - `"optimize-for-speed"` - Analysis is faster, but it is possible to
+     *   capture frames with lower quality
+     * - `"optimize-for-quality"` - Analysis is slower in order to capture high
+     *   quality frames.
+     * - `"default"` - Trade-off between quality and speed.
+     * - `"single-frame"` - Captures first acceptable frame.
+     */
+    captureStrategy: CaptureStrategy;
+    /**
+     * Enables document capture with a margin defined as the percentage of the
+     * dimensions of the framed document.
+     *
+     * Both margin and document are required to be fully visible on camera frame
+     * in order to finish capture.
+     *
+     * Allowed values are from 0 to 1. (0%-100%)
+     */
+    documentFramingMargin: number;
+    /**
+     * Whether to return an image of the transformed document with applied margin
+     * used during document framing.
+     */
+    keepMarginOnTransformedDocumentImage: boolean;
+    /**
+     * Parameters for lighting estimation.
+     *
+     * Thresholds used to classify the frame as too dark.
+     *
+     * If the calculated lighting score are outside these thresholds, the frame is
+     * discarded. Allowed values are from 0 to 1.
+     *
+     * ```typescript
+     * type LightingThresholds = {
+     *    tooDarkThreshold: number;
+     *    tooBrightThreshold: number;
+     * }
+     * ```
+     */
+    lightingThresholds: LightingThresholds;
+    /**
+     * Whether to discard frames with blurred documents.
+     *
+     * If it is enabled, the capture process is allowed to finish with blur on the
+     * document.
+     */
+    ignoreBlur: boolean;
+    /**
+     * Whether to discard frames with glare detected on the document.
+     *
+     * If it is enabled, the capture process is allowed to finish with glare on
+     * the document.
+     */
+    ignoreGlare: boolean;
+    /**
+     * Defines percentage of the document area that is allowed to be occluded by hand.
+     *
+     * Allowed values are from 0 to 1.
+     */
+    handOcclusionThreshold: number;
+    /**
+     * Threshold for detecting tilted documents. Frames with documents tilted more
+     * than defined by this threshold are discarded.
+     *
+     * Allowed values are from 0 to 1.
+     */
+    tiltThreshold: number;
+    /**
+     * Required minimum DPI of the captured document on transformed image.
+     *
+     * Affects how close the document needs to be to the camera in order to get
+     * captured.
+     *
+     * Allowed values are from 150 to 400.
+     */
+    minimumDocumentDpi: number;
+    /**
+     * Whether to automatically adjust minimum document dpi.
+     *
+     * If it is enabled, the minimum dpi is adjusted to optimal value for the
+     * provided input resolution to enable capture of all document groups.
+     */
+    adjustMinimumDocumentDpi: boolean;
+};
+
+export declare type BaltazarRequest = Readonly<{
+    licenseId: string;
+    licensee: string;
+    packageName: string;
+    platform: string;
+    sdkName: string;
+    sdkVersion: string;
+}>;
+
+export declare type BaltazarResponseData = {
+    [key: string]: string;
+};
+
+declare type Brand<T, Tbrand extends string> = T & {
+    [brand]: Tbrand;
+};
+
+declare const brand: unique symbol;
+
+declare interface CameraDeviceInfo extends Omit<MediaDeviceInfo, "kind"> {
+    kind: Extract<MediaDeviceInfo["kind"], "videoinput">;
+}
+
+export declare type CaptureBindings = {
+    initializeWithLicenseKey: (licenceKey: string, userId: string, allowHelloMessage: boolean) => LicenseUnlockResult;
+    Analyzer: typeof Analyzer;
+    submitServerPermission: (serverPermission: StringifiedBaltazarResponse) => ServerPermissionSubmitResult;
+};
+
+export declare type CaptureCallbacks = Partial<{
+    /**
+     * Will be called on every frame after it has finished processing
+     * @param frameResult Detailed information on the frame analysis result {@linkcode FrameAnalysisResult}
+     * @param frame {@linkcode ImageData} of the frame. Make sure to copy it as it
+     * will be overwritten when the next frame finishes processing.
+     */
+    onFrameAnalysis: (frameResult: FrameAnalysisResult, frame: ImageData) => void;
+    /**
+     * Will be called after the entire recognition process has finished successfully.
+     * @param result The result of the recognition process {@linkcode AnalyzerResult}
+     */
+    onCaptureResult: (result: AnalyzerResult) => void;
+}>;
+
+export declare type CaptureComponent = {
+    /** Dismounts the component from the DOM and unloads the SDK */
+    dismount: () => void;
+} & ExposedComponentApi;
+
+/**
+ * Singleton that represents the Capture SDK
+ */
+export declare interface CaptureSdk extends _CaptureSdk {
+}
+
+/**
+ * The class that represents the Capture SDK.
+ * Not exported to prevent manual instantiation.
+ * @private
+ */
+declare class _CaptureSdk {
+    #private;
+    constructor(directApi: DirectApi);
+    /**
+     * Single-time setup for a video element
+     */
+    setupVideoElement(videoElement: HTMLVideoElement): void;
+    /**
+     * Updates the analyzer. Capture process can't be active. Stop it using
+     * {@linkcode updateAnalyzerSettings} if required.
+     * @param settings {@linkcode AnalyzerSettings}. Will merge with the current
+     * settings.
+     */
+    updateAnalyzerSettings(settings: Partial<AnalyzerSettings>): Promise<void>;
+    /**
+     * Select a camera device from available ones.
+     *
+     * @param camera A camera device configured by the SDK. You can see available
+     * devices using on {@linkcode ReactiveStore.cameras} available by calling {@linkcode captureSdk.getState()}
+     */
+    selectCamera(camera: ConfiguredCamera): Promise<void>;
+    /**
+     * Refreshes available devices on the system and updates the state.
+     */
+    updateCameraDevices(): Promise<void>;
+    /**
+     * Starts the video playback
+     *
+     * @returns resolves when playback starts
+     */
+    startPlayback(): Promise<void>;
+    /**
+     * Starts a best-effort camera stream on a provided video element
+     */
+    startCameraStream(videoElement: HTMLVideoElement, autoplay?: boolean): Promise<void>;
+    /**
+     * Starts playback and capture.
+     */
+    startCapture(): Promise<void>;
+    /**
+     * Pauses the capture process without resetting the recognizer.
+     */
+    pauseCapture(): void;
+    /**
+     * Cancels the capture process. Unlike {@linkcode pauseCapture}, it also resets
+     * the analyzer.
+     */
+    cancelCapture(): Promise<void>;
+    /**
+     * Resets the currently active capturing process.
+     */
+    resetCapture(): Promise<void>;
+    /**
+     * Stops the currently active stream
+     */
+    stopStream(): Promise<void>;
+    /**
+     * Attempts to finish the side capture early.
+     *
+     * @returns `true` if there are enough captured frames to finish the current
+     * side capture, `false` otherwise.
+     */
+    finishSideCapture(): Promise<boolean>;
+    /**
+     * Pauses the video playback. This will also stop the capturing process.
+     */
+    pausePlayback(): void;
+    /**
+     * Set up callbacks on the SDK
+     *
+     * @param newCallbacks A subset of available
+     * {@linkcode CaptureCallbacks}. Will overwrite the previously set one.
+     *
+     * Send an empty object (`{}`) to clear callbacks.
+     */
+    setCallbacks(newCallbacks: CaptureCallbacks): void;
+    /**
+     * If true, the video and captured frames will be mirrored horizontally.
+     */
+    setMirrorX(mirrorX: boolean): void;
+    /**
+     * Allows the user to subscribe to state changes inside the Capture SDK.
+     * Implemented using Zustand. For usage information, see
+     * {@link https://github.com/pmndrs/zustand#using-subscribe-with-selector}
+     */
+    subscribe: {
+        (listener: (selectedState: ReactiveStore, previousSelectedState: ReactiveStore) => void): () => void;
+        <U>(selector: (state: ReactiveStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean | undefined;
+        } | undefined): () => void;
+    };
+    /**
+     * Gets the current internal state of the Capture SDK.
+     */
+    getState: () => ReactiveStore;
+    /**
+     * Resets the captureSdk and terminates the workers and the Wasm runtime.
+     */
+    destroy(): Promise<void>;
+}
+
+export declare type CaptureSdkSettings = Prettify<DirectApiSettings & {
+    /** Optional callbacks */
+    callbacks?: CaptureCallbacks;
+}>;
+
+/**
+ * Document side classification.
+ *
+ * If side classification was uncertain, `"unknown"` is returned.
+ */
+export declare type CaptureSide = "unknown" | "front" | "back";
+
+/**
+ * The capture state.
+ */
+export declare type CaptureState = "side-captured" | "document-captured" | "first-side-capture-in-progress" | "second-side-capture-in-progress";
+
+/**
+ * Capture strategy used to select the best frame.
+ *
+ * The following values are possible:
+ *
+ * - `"optimize-for-speed"` - Analysis is faster, but it is possible to capture
+ *   frames with lower quality
+ * - `"optimize-for-quality"` - Analysis is slower in order to capture high
+ *   quality frames.
+ * - `"default"` - Trade-off for quality and speed.
+ * - `"single-frame"` - Captures first acceptable frame.
+ */
+export declare type CaptureStrategy = "optimize-for-speed" | "optimize-for-quality" | "default" | "single-frame";
+
+/**
+ * Represents all bound properties on the Wasm object
+ */
+export declare type CaptureWasmModule = CaptureBindings & EmscriptenModule;
+
+declare class CaptureWorker {
+    #private;
+    /**
+     * @returns a Comlink-proxified instance of the Wasm module
+     */
+    loadWasm(): Promise<CaptureBindings & EmscriptenModule & ProxyMarked>;
+    /**
+     * Separate function so that we can set a finalizer on the analyzer.
+     */
+    createAnalyzer(): (Analyzer & ProxyMarked) | undefined;
+    /**
+     * Separate function so that we can clear the `imageData` buffer
+     */
+    analyze(image: Parameters<Analyzer["analyze"]>[0]): FrameAnalysisResult | FrameAnalysisError;
+    /**
+     * Terminates the workers and the Wasm runtime.
+     */
+    terminate(): void;
+    /** By default, the SDK will look for the required `/resources` directory on
+     * the current URL path.
+     *
+     * If you are hosting the resources on a different URL, provide a new relative
+     * or absolute one. The SDK will then search for files in the `/resources`
+     * directory of that URL.
+     */
+    setResourceUrl(url: string): void;
+    /**
+     * This method is called when the worker is terminated.
+     */
+    [finalizer](): void;
+}
+
+/**
+ * Completeness status of capture process.
+ */
+export declare type CompletenessStatus = "empty" | "one-side-missing" | "complete";
+
+export declare class ConfiguredCamera {
+    #private;
+    deviceInfo: CameraDeviceInfo;
+    settings: MediaTrackSettings;
+    activeStream: MediaStream | null;
+    name: string;
+    constructor(deviceInfo: CameraDeviceInfo, settings: MediaTrackSettings);
+    startStream(): Promise<MediaStream>;
+    stopStream(): void;
+    getVideoTrack(): MediaStreamTrack | undefined;
+}
+
+/**
+ * Creates a singleton instance of the Capture SDK.
+ * @param settings {@linkcode CaptureSdkSettings}
+ * @returns A singleton instance of {@linkcode CaptureSdk}
+ */
+export declare function createCaptureSdk(settings: CaptureSdkSettings): Promise<CaptureSdk>;
+
+/**
+ * Creates the capture UI and loads the SDK
+ *
+ * @param settings {@linkcode CreateCaptureUiSettings}
+ * @returns An object with methods for controlling the Capture SDK and the UI
+ * component
+ */
+export declare function createCaptureUi(settings: CreateCaptureUiSettings): Promise<CaptureComponent>;
+
+declare type CreateCaptureUiSettings = {
+    sdkSettings: CaptureSdkSettings;
+    uiSettings?: UiSettings;
+};
+
+/**
+ * Creates a new `DirectApi` instance.
+ * @param settings - The settings for the `DirectApi` instance.
+ * @returns A new `DirectApi` instance.
+ */
+export declare function createDirectApi(settings: DirectApiSettings): Promise<DirectApi>;
+
+declare const createEndpoint: unique symbol;
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+declare const _default: {
+    scan_the_front_side: string;
+    flip_document: string;
+    scan_the_back_side: string;
+    scanning_wrong_side: string;
+    move_closer: string;
+    move_farther: string;
+    camera_angle_too_steep: string;
+    document_too_close_to_edge: string;
+    rotate_phone_animation: string;
+    rotate_phone: string;
+    lightning_too_bright: string;
+    lightning_too_dark: string;
+    blur_detected: string;
+    glare_detected: string;
+    occluded: string;
+    need_help_tooltip: string;
+    onboarding_field_visible_title: string;
+    onboarding_field_visible_details: string;
+    tutorial_fields_visible_title: string;
+    tutorial_fields_visible_start: string;
+    tutorial_fields_visible_details: string;
+    tutorial_harsh_light_title: string;
+    tutorial_harsh_light_details: string;
+    tutorial_keep_still_title: string;
+    tutorial_keep_still_details: string;
+    camera_unavailable: string;
+    camera_permission_error: string;
+    settings: string;
+    camera_media_capture_error: string;
+    camera_unable_to_resume_session: string;
+    camera_query_in_progress: string;
+    done: string;
+    cancel: string;
+    back: string;
+    next: string;
+    ok: string;
+    dismiss: string;
+};
+
+/**
+ * The `DirectApi` is a wrapper around the `capture-worker` module.
+ *
+ * This is a low-level API that exposes the `capture-worker` module directly and
+ * should only be used if the `CaptureSDK` API isn't sufficient.
+ */
+export declare interface DirectApi extends _DirectApi {
+}
+
+/**
+ * The `_DirectApi` class is private to prevent manual instantiation.
+ * @private
+ */
+declare class _DirectApi {
+    #private;
+    constructor(remoteWorker: Remote<ProxyWorker>, remoteAnalyzer: Remote<Analyzer & ProxyMarked>);
+    /**
+     * Analyzes a single frame.
+     *
+     * @remarks
+     * This method is a proxy to the `capture-worker` module.
+     * It is a workaround to avoid memory leaks when using the `Remote` object
+     * directly.
+     *
+     * @param image - The image to analyze.
+     * @returns The analysis result or an error.
+     */
+    analyze: (image: ImageData) => Promise<FrameAnalysisResult | FrameAnalysisError>;
+    /**
+     * Attempts to finish the side capture early.
+     *
+     * If there aren't enough captured frames, the method returns `false` and
+     * further `Analyzer.analyze` calls are required.
+     *
+     * Otherwise, the method returns `true` and the `Analyzer` uses the best frame
+     * candidate to finish the side capture and either finish the capture process
+     * or continue to the next side.
+     *
+     * @returns `true` if there are enough captured frames to finish the capture
+     * process and `getResult` can be called, `false` otherwise.
+     */
+    finishSideCapture: () => Promise<boolean>;
+    /**
+     * Returns the analyzer result.
+     * @returns The analysis result.
+     */
+    getResult: () => Promise<AnalyzerResult>;
+    /**
+     * Returns the analyzer settings.
+     * @returns The analyzer settings.
+     */
+    getSettings: () => Promise<AnalyzerSettings>;
+    /**
+     * Updates the analyzer settings. The new settings are merged with the current
+     * settings.
+     *
+     * Don't update settings in the middle of a capture session. Call
+     * `resetCapture` first.
+     *
+     * @param newSettings - The new analyzer settings. Can be a partial object.
+     */
+    updateSettings: (newSettings: Partial<AnalyzerSettings>) => Promise<void>;
+    /**
+     * Resets the currently active capturing process.
+     */
+    resetCapture: () => Promise<void>;
+    /**
+     * Terminates the workers and the Wasm runtime.
+     */
+    terminateWorker(): Promise<void>;
+}
+
+export declare type DirectApiSettings = {
+    /** The licence key for loading the Capture SDK. Required. */
+    licenseKey: string;
+    /** Custom settings for the Capture analyzer */
+    analyzerSettings?: Partial<AnalyzerSettings>;
+    /** By default, the SDK will look for the required `/resources` directory on
+     the current URL path.
+     *
+     If you are hosting the resources on a different URL, provide a new relative
+     or absolute one. The SDK will then search for files in the `/resources`
+     directory of that URL.
+     */
+    resourceUrl?: string;
+};
+
+/**
+ * The document blur status for the current frame.
+ */
+export declare type DocumentBlurStatus = "not-available" | "blur-detected" | "blur-not-detected";
+
+/**
+ *  The document framing status for the current frame.
+ */
+export declare type DocumentFramingStatus = "not-available" | "no-document" | "camera-too-far" | "camera-too-close" | "camera-angle-too-steep" | "camera-orientation-unsuitable" | "document-too-close-to-frame-edge" | "ok";
+
+/**
+ * The document glare status for the current frame.
+ */
+export declare type DocumentGlareStatus = "not-available" | "glare-detected" | "glare-not-detected";
+
+/**
+ * Document group classification.
+ */
+export declare type DocumentGroup = "unknown" | "dl" | "id" | "passport" | "passport-card" | "visa";
+
+/**
+ * The document lighting status for the current frame.
+ */
+export declare type DocumentLightingStatus = "not-available" | "too-bright" | "too-dark" | "normal";
+
+/**
+ * The document occlusion status for the current frame.
+ */
+export declare type DocumentOcclusionStatus = "not-available" | "occluded" | "not-occluded";
+
+/**
+ * Analysis status of the document side for the current frame.
+ */
+export declare type DocumentSideAnalysisStatus = "not-available" | "side-already-captured" | "side-not-captured";
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+/**
+ * Specifies an abstract object placed on the WebAssembly heap.
+ * Objects placed on the WebAssembly heap are not cleaned up by the
+ * garbage collector of the JavaScript engine. The memory used by
+ * the object must be cleaned up manually by calling the delete() method.
+ *
+ * {@link} https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-management
+ */
+declare abstract class EmbindObject {
+    /**
+     * Cleans up the object from the WebAssembly heap.
+     */
+    delete(): Promise<void>;
+}
+
+export declare type ExposedComponentApi = {
+    /** Can return undefined if called after the SDK has been
+     * destroyed
+     */
+    captureSdk: CaptureSdk | undefined;
+    updateLocalization: SetStoreFunction<LocalizationStrings>;
+};
+
+declare class FeedbackParser {
+    private timeWindow;
+    private decayRate;
+    private eventStack;
+    private currentUiState;
+    private currentStateStartTime;
+    reset(): void;
+    /**
+     * Returns a weighted UI state based on the history
+     */
+    getUiState(frameAnalysisResult: FrameAnalysisResult): Readonly<{
+        key: UiStateKey;
+        reticleType: ReticleType;
+        minDuration: number;
+    }>;
+    /**
+     * Returns a requested UI state key based on the latest frame
+     */
+    private getUiStateKeyFromResult;
+}
+
+export declare const feedbackParser: FeedbackParser;
+
+declare const finalizer: unique symbol;
+
+/**
+ * The return type of `Analyzer.analyze` when an error occurs.
+ */
+export declare type FrameAnalysisError = {
+    error: FrameAnalysisErrorType;
+};
+
+/**
+ * The type of error that can occur during frame analysis.
+ */
+export declare type FrameAnalysisErrorType = "analyzer-settings-unsuitable-error" | "unknown-error";
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+/**
+ * The return type of `Analyzer.analyze`. It contains the current capture state
+ * and frame analysis status.
+ */
+export declare type FrameAnalysisResult = {
+    captureState: CaptureState;
+    frameCaptured: boolean;
+    frameAnalysisStatus: FrameAnalysisStatus;
+};
+
+/**
+ * The frame analysis status.
+ */
+export declare type FrameAnalysisStatus = {
+    sideAnalysisStatus: DocumentSideAnalysisStatus;
+    framingStatus: DocumentFramingStatus;
+    lightingStatus: DocumentLightingStatus;
+    blurStatus: DocumentBlurStatus;
+    glareStatus: DocumentGlareStatus;
+    occlusionStatus: DocumentOcclusionStatus;
+};
+
+export declare const getBase64StringFromDataURL: (dataURL: string) => string;
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+export declare const imageDataToUrl: (imageData: ImageData) => string;
+
+export declare enum LicenseTokenState {
+    Invalid = 0,
+    RequiresServerPermission = 1,
+    Valid = 2
+}
+
+/**
+ * Copyright (c) 2023 Microblink Ltd. All rights reserved.
+ *
+ * ANY UNAUTHORIZED USE OR SALE, DUPLICATION, OR DISTRIBUTION
+ * OF THIS PROGRAM OR ANY OF ITS PARTS, IN SOURCE OR BINARY FORMS,
+ * WITH OR WITHOUT MODIFICATION, WITH THE PURPOSE OF ACQUIRING
+ * UNLAWFUL MATERIAL OR ANY OTHER BENEFIT IS PROHIBITED!
+ * THIS PROGRAM IS PROTECTED BY COPYRIGHT LAWS AND YOU MAY NOT
+ * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
+ */
+export declare type LicenseUnlockResult = Readonly<{
+    isTrial: boolean;
+    licenseId: string;
+    licensee: string;
+    packageName: string;
+    sdkName: string;
+    sdkVersion: string;
+    unlockResult: LicenseTokenState;
+    licenseError: string;
+}>;
+
+/**
+ * Parameters for lighting estimation.
+ *
+ * Thresholds used to classify the frame as too dark.
+ *
+ * If the calculated lighting score are outside these thresholds, the frame is
+ * discarded. Allowed values are from 0 to 1.
+ */
+export declare type LightingThresholds = {
+    tooDarkThreshold: number;
+    tooBrightThreshold: number;
+};
+
+/**
+ * Takes the raw type of a remote object, function or class as a remote thread would see it through a proxy (e.g. when
+ * passed in as a function argument) and returns the type the local thread has to supply.
+ *
+ * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.
+ */
+declare type Local<T> = Omit<LocalObject<T>, keyof ProxyMethods> & (T extends (...args: infer TArguments) => infer TReturn ? (...args: {
+    [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
+}) => MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>> : unknown) & (T extends {
+    new (...args: infer TArguments): infer TInstance;
+} ? {
+    new (...args: {
+        [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
+    }): MaybePromise<Local<Unpromisify<TInstance>>>;
+} : unknown);
+
+declare type LocalizationStrings = typeof _default;
+
+/**
+ * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This does not handle call signatures, which is handled by the more general `Local<T>` type.
+ *
+ * This is the inverse of `RemoteObject<T>`.
+ *
+ * @template T The type of a proxied object.
+ */
+declare type LocalObject<T> = {
+    [P in keyof T]: LocalProperty<T[P]>;
+};
+
+/**
+ * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function
+ * argument) and returns the type that the local thread has to supply.
+ *
+ * This is the inverse of `RemoteProperty<T>`.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See
+ * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+declare type LocalProperty<T> = T extends Function | ProxyMarked ? Local<T> : Unpromisify<T>;
+
+/**
+ * Expresses that a type can be either a sync or async.
+ */
+declare type MaybePromise<T> = Promise<T> | T;
+
+/**
+ * Displays the resolved type instead of intersections.
+ */
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+/**
+ * Takes a type and wraps it in a Promise, if it not already is one.
+ * This is to avoid `Promise<Promise<T>>`.
+ *
+ * This is the inverse of `Unpromisify<T>`.
+ */
+declare type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
+
+/**
+ * Interface of values that were marked to be proxied with `comlink.proxy()`.
+ * Can also be implemented by classes.
+ */
+declare interface ProxyMarked {
+    [proxyMarker]: true;
+}
+
+declare const proxyMarker: unique symbol;
+
+/**
+ * Additional special comlink methods available on each proxy returned by `Comlink.wrap()`.
+ */
+declare interface ProxyMethods {
+    [createEndpoint]: () => Promise<MessagePort>;
+    [releaseProxy]: () => void;
+}
+
+/**
+ * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).
+ */
+declare type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;
+
+declare type ProxyWorker = Omit<CaptureWorker, typeof finalizer>;
+
+export declare type ReactiveStore = {
+    /**
+     * The video element that is currently being used for capture.
+     */
+    videoElement: HTMLVideoElement | null;
+    /**
+     * The list of cameras that are available to the user.
+     */
+    cameras: ConfiguredCamera[];
+    /**
+     * The currently selected camera.
+     */
+    selectedCamera: ConfiguredCamera | null;
+    /**
+     * The callbacks that are used to communicate with the capture sdk.
+     */
+    callbacks: CaptureCallbacks;
+    /**
+     * Whether the camera stream is currently active and playing back on the video
+     * element.
+     */
+    isPlaying: boolean;
+    /**
+     * Whether the active video stream is currently being captured and processed
+     * by the Analyzer.
+     */
+    isCapturing: boolean;
+    /**
+     * Whether the camera is currently being swapped.
+     */
+    isSwappingCamera: boolean;
+    /**
+     * Whether the camera list is currently being queried.
+     */
+    isQueryingCameras: boolean;
+    /**
+     * The analyzer settings that are currently being used.
+     */
+    analyzerSettings: AnalyzerSettings;
+    /**
+     * Indicates if the captured frames will be mirrored horizontally
+     */
+    mirrorX: boolean;
+    /**
+     * The current UI state. Represents the current feedback messages being shown
+     * to the user.
+     */
+    uiState: UiState;
+    /**
+     * Whether the capture requires landscape mode.
+     */
+    captureRequiresLandscape: boolean;
+    /**
+     * Whether the SDK has been initialized.
+     */
+    initialized: boolean;
+    /**
+     * If the SDK has encountered an error, this will be set to the error.
+     */
+    errorState: Error | null;
+};
+
+declare const releaseProxy: unique symbol;
+
+/**
+ * Takes the raw type of a remote object, function or class in the other thread and returns the type as it is visible to
+ * the local thread from the proxy return value of `Comlink.wrap()` or `Comlink.proxy()`.
+ */
+declare type Remote<T> = RemoteObject<T> & (T extends (...args: infer TArguments) => infer TReturn ? (...args: {
+    [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
+}) => Promisify<ProxyOrClone<Unpromisify<TReturn>>> : unknown) & (T extends {
+    new (...args: infer TArguments): infer TInstance;
+} ? {
+    new (...args: {
+        [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
+    }): Promisify<Remote<TInstance>>;
+} : unknown) & ProxyMethods;
+
+/**
+ * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread
+ * when proxied with `Comlink.proxy()`.
+ *
+ * This does not handle call signatures, which is handled by the more general `Remote<T>` type.
+ *
+ * @template T The raw type of a remote object as seen in the other thread.
+ */
+declare type RemoteObject<T> = {
+    [P in keyof T]: RemoteProperty<T[P]>;
+};
+
+/**
+ * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
+ *
+ * Note: This needs to be its own type alias, otherwise it will not distribute over unions.
+ * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
+ */
+declare type RemoteProperty<T> = T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;
+
+/**
+ * Resets the store to its initial state.
+ * Stops all camera streams as a side effect.
+ */
+export declare const resetCoreStore: () => void;
+
+export declare type ReticleType = "searching" | "processing" | "error" | "done" | "flip" | "rotate";
+
+export declare type ServerPermissionSubmitResult = Readonly<{
+    status: ServerPermissionSubmitResultStatus;
+    lease: number;
+    networkErrorDescription?: string;
+}>;
+
+export declare enum ServerPermissionSubmitResultStatus {
+    Ok = 0,
+    NetworkError = 1,
+    RemoteLock = 2,
+    PermissionExpired = 3,
+    PayloadCorrupted = 4,
+    PayloadSignatureVerificationFailed = 5,
+    IncorrectTokenState = 6
+}
+
+declare type SetStateInternal<T> = {
+    _(partial: T | Partial<T> | {
+        _(state: T): T | Partial<T>;
+    }['_'], replace?: boolean | undefined): void;
+}['_'];
+
+/**
+ * Capture result of a single document side.
+ */
+export declare type SideCaptureResult = {
+    /**
+     * Original image of the captured document side, untransformed, as it was used
+     * in the analysis.
+     */
+    imageResult: ImageData;
+    /**
+     * Image of the cropped and perspective-corrected document. The transformed
+     * image is returned in the correct orientation.
+     */
+    transformedImageResult: ImageData | null;
+    /**
+     * Document side classification.
+     *
+     * If the side classification was uncertain, `"unknown"` is returned.
+     */
+    side: CaptureSide;
+    /**
+     * If the document is captured at lower dpi than `minimumDocumentDpi` from settings,
+     * flag is set to `true`.
+     */
+    dpiAdjusted: boolean;
+};
+
+declare interface StoreApi<T> {
+    setState: SetStateInternal<T>;
+    getState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+    /**
+     * @deprecated Use `unsubscribe` returned by `subscribe`
+     */
+    destroy: () => void;
+}
+
+/**
+ * Branded type for type safety. Requires casting where required.
+ */
+export declare type StringifiedBaltazarResponse = Brand<string, "StringifiedBaltazarResponse">;
+
+declare type UiSettings = {
+    /** Target DOM node where you want the UI component to mount.
+     *
+     * If not provided, the component will be portalled in the document root,
+     * taking up the entire screen.
+     */
+    target?: MountableElement;
+    /** If `true`, an onboarding screen will be visible once the video feed starts.
+     *
+     * @default `true`
+     *  */
+    showTutorial?: boolean;
+    /** If `true`, errors thrown in the SDK will be shown in a dialog.
+     *
+     * @default `true`
+     *  */
+    showErrorDialog?: boolean;
+    /**
+     * User provided localization keys
+     */
+    localization?: Partial<Record<keyof LocalizationStrings, string>>;
+};
+
+export declare type UiState = Readonly<{
+    key: UiStateKey;
+    reticleType: ReticleType;
+    minDuration: number;
+}>;
+
+export declare type UiStateEvent = {
+    stateKey: Readonly<UiStateKey>;
+    timeStamp: Readonly<DOMHighResTimeStamp>;
+    currentWeight: number;
+};
+
+export declare type UiStateKey = "PROCESSING" | "SIDE_CAPTURED" | "DOCUMENT_CAPTURED" | "SENSING_FRONT" | "SENSING_BACK" | "DOCUMENT_FRAMING_CAMERA_TOO_FAR" | "DOCUMENT_FRAMING_CAMERA_TOO_CLOSE" | "DOCUMENT_FRAMING_CAMERA_ORIENTATION_UNSUITABLE" | "DOCUMENT_FRAMING_CAMERA_ORIENTATION_UNSUITABLE_ANIMATION" | "DOCUMENT_FRAMING_CAMERA_ANGLE_TOO_STEEP" | "DOCUMENT_TOO_CLOSE_TO_FRAME_EDGE" | "LIGHTING_TOO_DARK" | "LIGHTING_TOO_BRIGHT" | "BLUR_DETECTED" | "GLARE_DETECTED" | "OCCLUDED" | "WRONG_SIDE";
+
+export declare const uiStateMap: Readonly<Record<UiStateKey, UiState>>;
+
+/**
+ * Takes a type that may be Promise and unwraps the Promise type.
+ * If `P` is not a Promise, it returns `P`.
+ *
+ * This is the inverse of `Promisify<T>`.
+ */
+declare type Unpromisify<P> = P extends Promise<infer T> ? T : P;
+
+/**
+ * Inverse of `ProxyOrClone<T>`.
+ */
+declare type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked> ? Local<T> : T;
+
+/**
+ * ⚠️ DANGER AHEAD ⚠️
+ *
+ * The Zustand store. Use only if you know what you're doing.
+ *
+ * Never set the state as this will break the application logic. We do not have
+ * two-way binding. Make sure you only observe the state.
+ *
+ * Prefer using subscriptions if you require observable state.
+ *
+ * {@link https://github.com/pmndrs/zustand}
+ */
+export declare const zustandStore: Omit<StoreApi<ReactiveStore>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: ReactiveStore, previousSelectedState: ReactiveStore) => void): () => void;
+        <U>(selector: (state: ReactiveStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean | undefined;
+        } | undefined): () => void;
+    };
+};
+
+export { }