@microblink/capture 1.0.0

package/types/index.d.ts

@@ -0,0 +1,913 @@
+import { MountableElement } from 'solid-js/web';
+import { SetStoreFunction } from 'solid-js/store';
+
+export declare class Analyzer extends EmbindObject {
+    /**
+     * Performs frame analysis and returns `FrameAnalysisResult`
+     */
+    analyze(image: ImageData): FrameAnalysisResult;
+    getResult: () => AnalyzerResult;
+    getSettings: () => AnalyzerSettings;
+    updateSettings: (settings: AnalyzerSettings) => void;
+    /** Returns analyzer to initial state */
+    reset: () => void;
+    /**
+     * Method used to finish capture of current side when `Analyzer.analyze()`
+     * didn't return {@linkcode FrameAnalysisResult#frameAnalysisStatus} state.
+     *
+     * Method tries to fill `SideCaptureResult` with current best frame, if there
+     * isn't one method returns `false` and result is not changed, otherwise
+     * `true` is returned and current best frame is filled in current
+     * `SideCaptureResult`.
+     */
+    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.analyze`
+ */
+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 */
+    completnessStatus: CompletnessStatus;
+};
+
+/**
+ * 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 all possible 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 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.
+     */
+    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.
+     */
+    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;
+};
+
+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">;
+}
+
+/**
+ * Cancels the capture process. Unlike {@linkcode pauseCapture}, it also resets
+ * the analyzer.
+ */
+declare function cancelCapture(): Promise<void>;
+
+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 frame {@linkcode ImageData} of the frame. Make sure to copy it as it
+     * will be overwritten when the next frame finishes processing.
+     * @param frameResult Detailed information on the frame analysis
+     */
+    onFrameAnalysis: (frame: ImageData, frameResult: FrameAnalysisResult) => void;
+    /**
+     * Will be called after the entire recognition process has finished successfully.
+     * @param result The result
+     */
+    onCaptureResult: (result: AnalyzerResult) => void;
+}>;
+
+export declare type CaptureComponent = {
+    /** Dismounts the component from the DOM and unloads the SDK */
+    dismount: () => void;
+} & ExposedComponentApi;
+
+/** The exported API available to the user */
+export declare type CaptureSdk = typeof captureSdk;
+
+/**
+ * The core singleton with all public API methods.
+ *
+ * Always defined in external scopes, as it's only accessible as a return value
+ * of {@linkcode createCaptureSdk}
+ *
+ */
+declare const captureSdk: {
+    /**
+     * Starts a best-effort camera stream on a provided video element
+     */
+    startCameraStream: typeof startCameraStream;
+    /**
+     * Stops the currently active stream
+     */
+    stopStream: typeof stopStream;
+    /**
+     * Starts the video playback
+     *
+     * @returns resolves when playback starts
+     */
+    startPlayback: typeof startPlayback;
+    /**
+     * Pauses the video playback. This will also stop the capturing process.
+     */
+    pausePlayback: typeof pausePlayback;
+    /**
+     * Starts playback and capture.
+     */
+    startCapture: typeof startCapture;
+    /**
+     * Pauses the capture process without resetting the recognizer.
+     */
+    pauseCapture: typeof pauseCapture;
+    /**
+     * Cancels the capture process. Unlike {@linkcode pauseCapture}, it also resets
+     * the analyzer.
+     */
+    cancelCapture: typeof cancelCapture;
+    /**
+     * Finishes capturing the current side
+     */
+    finishSideCapture: typeof finishSideCapture;
+    /**
+     * Resets the analyzer.
+     */
+    resetAnalyzer: typeof resetAnalyzer;
+    /**
+     * 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: typeof selectCamera;
+    /**
+     * Refreshes available devices on the system and updates the state.
+     */
+    updateCameraDevices: typeof updateCameraDevices;
+    /**
+     * 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: typeof setCallbacks;
+    /**
+     * 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: typeof updateAnalyzerSettings;
+    /**
+     * 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 SDK core and terminates the workers and the Wasm runtime.
+     */
+    destroy: typeof destroy;
+};
+
+export declare type CaptureSdkSettings = {
+    /** The licence key for loading the Capture SDK. Required. */
+    licenseKey: string;
+    /** Optional callbacks */
+    callbacks?: CaptureCallbacks;
+    /** 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.
+     */
+    resourceUrl?: string;
+};
+
+/**
+ * Document side classification.
+ *
+ *  If side classification was uncertain, `"unknown"` is returned.
+ */
+export declare type CaptureSide = "unknown" | "front" | "back";
+
+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;
+
+/**
+ * Completeness status of capture process
+ */
+export declare type CompletnessStatus = "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;
+}
+
+/**
+ * Main function that loads the SDK and returns a `captureSdk` object
+ */
+export declare function createCaptureSdk(settings: CaptureSdkSettings): Promise<{
+    /**
+     * Starts a best-effort camera stream on a provided video element
+     */
+    startCameraStream: typeof startCameraStream;
+    /**
+     * Stops the currently active stream
+     */
+    stopStream: typeof stopStream;
+    /**
+     * Starts the video playback
+     *
+     * @returns resolves when playback starts
+     */
+    startPlayback: typeof startPlayback;
+    /**
+     * Pauses the video playback. This will also stop the capturing process.
+     */
+    pausePlayback: typeof pausePlayback;
+    /**
+     * Starts playback and capture.
+     */
+    startCapture: typeof startCapture;
+    /**
+     * Pauses the capture process without resetting the recognizer.
+     */
+    pauseCapture: typeof pauseCapture;
+    /**
+     * Cancels the capture process. Unlike {@linkcode pauseCapture}, it also resets
+     * the analyzer.
+     */
+    cancelCapture: typeof cancelCapture;
+    /**
+     * Finishes capturing the current side
+     */
+    finishSideCapture: typeof finishSideCapture;
+    /**
+     * Resets the analyzer.
+     */
+    resetAnalyzer: typeof resetAnalyzer;
+    /**
+     * 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: typeof selectCamera;
+    /**
+     * Refreshes available devices on the system and updates the state.
+     */
+    updateCameraDevices: typeof updateCameraDevices;
+    /**
+     * 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: typeof setCallbacks;
+    /**
+     * 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: typeof updateAnalyzerSettings;
+    /**
+     * 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 SDK core and terminates the workers and the Wasm runtime.
+     */
+    destroy: typeof destroy;
+}>;
+
+/** Creates the capture UI and loads the SDK */
+export declare function createCaptureUi(settings: CreateCaptureUiSettings): Promise<CaptureComponent>;
+
+/**
+ * Loads the UI component along with the Capture SDK.
+ *
+ * @param target The DOM node you want to render the Capture UI component to
+ * @param sdkSettings Settings for the Capture SDK
+ * @param uiSettings Settings for the Capture SDK UI component
+ * @returns An object with methods for controlling the Capture SDK and the UI
+ * component
+ *
+ * @example
+ * ```typescript
+ * // Load the UI and the SDK
+ * const captureComponent = await createCaptureUi({
+ *   sdkSettings: {
+ *     licenseKey: "YOUR_LICENCE_KEY",
+ *     callbacks: {
+ *       onCaptureResult: (result) => console.log(result),
+ *     },
+ *   },
+ * });
+ *
+ * // Will dismount and clean up
+ * captureComponent.dismount()
+ * ```
+ */
+declare type CreateCaptureUiSettings = {
+    sdkSettings: CaptureSdkSettings;
+    uiSettings?: UiSettings;
+};
+
+/**
+ * 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;
+    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;
+};
+
+/**
+ * Resets the captureSdk and terminates the workers and the Wasm runtime.
+ */
+declare function destroy(): Promise<void>;
+
+export declare type DocumentBlurStatus = "not-available" | "blur-detected" | "blur-not-detected";
+
+export declare type DocumentFramingStatus = "not-available" | "no-document" | "camera-too-far" | "camera-too-close" | "camera-angle-too-steep" | "document-too-close-to-frame-edge" | "ok";
+
+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";
+
+export declare type DocumentLightingStatus = "not-available" | "too-bright" | "too-dark" | "normal";
+
+export declare type DocumentOcclusionStatus = "not-available" | "occluded" | "not-occluded";
+
+/** Back side analysis */
+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>;
+};
+
+export declare class FeedbackParser {
+    private timeWindow;
+    private decayRate;
+    private eventStack;
+    private analyzerSettings;
+    private currentUiState;
+    private currentStateStartTime;
+    constructor(analyzerSettings: AnalyzerSettings);
+    reset(): void;
+    updateSettings(analyzerSettings: AnalyzerSettings): 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;
+}
+
+/**
+ * Finishes capturing the current side
+ */
+declare function finishSideCapture(): Promise<void>;
+
+/**
+ * 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 FrameAnalysisResult = {
+    captureState: CaptureState;
+    frameCaptured: boolean;
+    frameAnalysisStatus: FrameAnalysisStatus;
+};
+
+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;
+};
+
+declare type LocalizationStrings = typeof _default;
+
+/**
+ * Pauses the capture process without resetting the recognizer.
+ */
+declare function pauseCapture(): void;
+
+/**
+ * Pauses the video playback. This will also stop the capturing process.
+ */
+declare function pausePlayback(): void;
+
+export declare type ReactiveStore = {
+    videoElement: HTMLVideoElement | null;
+    cameras: ConfiguredCamera[];
+    selectedCamera: ConfiguredCamera | null;
+    callbacks: CaptureCallbacks;
+    isPlaying: boolean;
+    isCapturing: boolean;
+    isSwappingCamera: boolean;
+    isQueryingCameras: boolean;
+    analyzerSettings: AnalyzerSettings;
+    uiState: UiState;
+    /** If Wasm is initialized successfully */
+    initialized: boolean;
+    errorState: Error | null;
+};
+
+/**
+ * Resets the analyzer.
+ */
+declare function resetAnalyzer(): Promise<void>;
+
+export declare const resetCoreStore: () => void;
+
+export declare type ReticleType = "searching" | "processing" | "error" | "done" | "flip";
+
+/**
+ * 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()}
+ */
+declare function selectCamera(camera: ConfiguredCamera): Promise<void>;
+
+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
+}
+
+/**
+ * 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.
+ */
+declare function setCallbacks(newCallbacks: CaptureCallbacks): void;
+
+declare type SetStateInternal<T> = {
+    _(partial: T | Partial<T> | {
+        _(state: T): T | Partial<T>;
+    }['_'], replace?: boolean | undefined): void;
+}['_'];
+
+/**
+ * Result of side capture
+ */
+export declare type SideCaptureResult = {
+    /**
+     * Original image of the captured document, untransformed, as it was used in
+     * 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 side classification was uncertain, `"unknown"` is returned.
+     */
+    side: CaptureSide;
+};
+
+/**
+ * Starts a best-effort camera stream on a provided video element
+ */
+declare function startCameraStream(videoElement: HTMLVideoElement, autoplay?: boolean): Promise<void>;
+
+/**
+ * Starts playback and capture.
+ */
+declare function startCapture(): Promise<void>;
+
+/**
+ * Starts the video playback
+ *
+ * @returns resolves when playback starts
+ */
+declare function startPlayback(): Promise<void>;
+
+/**
+ * Stops the currently active stream
+ */
+declare function stopStream(): Promise<void>;
+
+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" | "FLIP_CARD" | "DOCUMENT_CAPTURED" | "SENSING_FRONT" | "SENSING_BACK" | "DOCUMENT_FRAMING_CAMERA_TOO_FAR" | "DOCUMENT_FRAMING_CAMERA_TOO_CLOSE" | "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>>;
+
+/**
+ * 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.
+ */
+declare function updateAnalyzerSettings(settings: Partial<AnalyzerSettings>): Promise<void>;
+
+/**
+ * Refreshes available devices on the system and updates the state.
+ */
+declare function updateCameraDevices(): Promise<void>;
+
+/**
+ * ⚠️ DANGER AHEAD ⚠️
+ *
+ * The Zustand store. Use only if you know what you're doing.
+ *
+ * Never use setters 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 { }