@microblink/capture 1.0.8 → 1.1.0

package/types/index.d.ts

@@ -1,24 +1,40 @@
+/// <reference types="emscripten" />
+
 import { MountableElement } from 'solid-js/web';
 import { SetStoreFunction } from 'solid-js/store';
 
 export declare class Analyzer extends EmbindObject {
     /**
-     * Performs frame analysis and returns `FrameAnalysisResult`
+     * 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.
      */
-    analyze(image: ImageData): FrameAnalysisResult;
     getResult: () => AnalyzerResult;
+    /**
+     * Returns the analyzer settings.
+     */
     getSettings: () => AnalyzerSettings;
+    /**
+     * Updates the analyzer settings.
+     */
     updateSettings: (settings: AnalyzerSettings) => void;
-    /** Returns analyzer to initial state */
+    /** Resets the currently active capturing process. */
     reset: () => void;
     /**
-     * Method used to finish capture of current side when `Analyzer.analyze()`
-     * didn't return {@linkcode FrameAnalysisResult#frameAnalysisStatus} state.
+     * 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.
      *
-     * 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`.
+     * 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;
 }
@@ -34,7 +50,7 @@ export declare class Analyzer extends EmbindObject {
  * REVERSE ENGINEER, DECOMPILE, OR DISASSEMBLE IT.
  */
 /**
- * The result returned from `Analyzer.analyze`
+ * The result returned from `Analyzer.getResult`
  */
 export declare type AnalyzerResult = {
     /** Result of the first side capture */
@@ -44,7 +60,7 @@ export declare type AnalyzerResult = {
     /** Document group */
     documentGroup: DocumentGroup;
     /** Completeness status of the capture process */
-    completnessStatus: CompletnessStatus;
+    completenessStatus: CompletenessStatus;
 };
 
 /**
@@ -62,7 +78,7 @@ export declare type AnalyzerResult = {
  */
 export declare type AnalyzerSettings = {
     /**
-     * Whether to capture a single side or capture all possible sides
+     * Whether to capture a single side or capture both sides
      * of a document with automatic side detection.
      */
     captureSingleSide: boolean;
@@ -71,7 +87,7 @@ export declare type AnalyzerSettings = {
      */
     returnTransformedDocumentImage: boolean;
     /**
-     * Configures capture strategy used to select the best frame.
+     * Configures the capture strategy used to select the best frame.
      *
      * The following values are possible:
      *
@@ -79,7 +95,7 @@ export declare type AnalyzerSettings = {
      *   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.
+     * - `"default"` - Trade-off between quality and speed.
      * - `"single-frame"` - Captures first acceptable frame.
      */
     captureStrategy: CaptureStrategy;
@@ -90,7 +106,7 @@ export declare type AnalyzerSettings = {
      * 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.
+     * Allowed values are from 0 to 1. (0%-100%)
      */
     documentFramingMargin: number;
     /**
@@ -150,6 +166,13 @@ export declare type AnalyzerSettings = {
      * 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<{
@@ -175,12 +198,6 @@ 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;
@@ -190,14 +207,14 @@ export declare type CaptureBindings = {
 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.
-     * @param frameResult Detailed information on the frame analysis
      */
-    onFrameAnalysis: (frame: ImageData, frameResult: FrameAnalysisResult) => void;
+    onFrameAnalysis: (frameResult: FrameAnalysisResult, frame: ImageData) => void;
     /**
      * Will be called after the entire recognition process has finished successfully.
-     * @param result The result
+     * @param result The result of the recognition process {@linkcode AnalyzerResult}
      */
     onCaptureResult: (result: AnalyzerResult) => void;
 }>;
@@ -207,67 +224,84 @@ export declare type CaptureComponent = {
     dismount: () => void;
 } & ExposedComponentApi;
 
-/** The exported API available to the user */
-export declare type CaptureSdk = typeof captureSdk;
+/**
+ * Singleton that represents the Capture SDK
+ */
+export declare interface CaptureSdk extends _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}
- *
+ * The class that represents the Capture SDK.
+ * Not exported to prevent manual instantiation.
+ * @private
  */
-declare const captureSdk: {
+declare class _CaptureSdk {
+    #private;
+    constructor(directApi: DirectApi);
     /**
-     * Starts a best-effort camera stream on a provided video element
+     * Single-time setup for a video element
      */
-    startCameraStream: typeof startCameraStream;
+    setupVideoElement(videoElement: HTMLVideoElement): void;
     /**
-     * Stops the currently active stream
+     * 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.
      */
-    stopStream: typeof stopStream;
+    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: typeof startPlayback;
+    startPlayback(): Promise<void>;
     /**
-     * Pauses the video playback. This will also stop the capturing process.
+     * Starts a best-effort camera stream on a provided video element
      */
-    pausePlayback: typeof pausePlayback;
+    startCameraStream(videoElement: HTMLVideoElement, autoplay?: boolean): Promise<void>;
     /**
      * Starts playback and capture.
      */
-    startCapture: typeof startCapture;
+    startCapture(): Promise<void>;
     /**
      * Pauses the capture process without resetting the recognizer.
      */
-    pauseCapture: typeof pauseCapture;
+    pauseCapture(): void;
     /**
      * Cancels the capture process. Unlike {@linkcode pauseCapture}, it also resets
      * the analyzer.
      */
-    cancelCapture: typeof cancelCapture;
+    cancelCapture(): Promise<void>;
     /**
-     * Finishes capturing the current side
+     * Resets the currently active capturing process.
      */
-    finishSideCapture: typeof finishSideCapture;
+    resetCapture(): Promise<void>;
     /**
-     * Resets the analyzer.
+     * Stops the currently active stream
      */
-    resetAnalyzer: typeof resetAnalyzer;
+    stopStream(): Promise<void>;
     /**
-     * Select a camera device from available ones.
+     * Attempts to finish the side capture early.
      *
-     * @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()}
+     * @returns `true` if there are enough captured frames to finish the current
+     * side capture, `false` otherwise.
      */
-    selectCamera: typeof selectCamera;
+    finishSideCapture(): Promise<boolean>;
     /**
-     * Refreshes available devices on the system and updates the state.
+     * Pauses the video playback. This will also stop the capturing process.
      */
-    updateCameraDevices: typeof updateCameraDevices;
+    pausePlayback(): void;
     /**
      * Set up callbacks on the SDK
      *
@@ -276,17 +310,15 @@ declare const captureSdk: {
      *
      * Send an empty object (`{}`) to clear callbacks.
      */
-    setCallbacks: typeof setCallbacks;
+    setCallbacks(newCallbacks: CaptureCallbacks): 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.
+     * If true, the video and captured frames will be mirrored horizontally.
      */
-    updateAnalyzerSettings: typeof updateAnalyzerSettings;
+    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}
+     * 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;
@@ -300,32 +332,26 @@ declare const captureSdk: {
      */
     getState: () => ReactiveStore;
     /**
-     * Resets the SDK core and terminates the workers and the Wasm runtime.
+     * Resets the captureSdk and terminates the workers and the Wasm runtime.
      */
-    destroy: typeof destroy;
-};
+    destroy(): Promise<void>;
+}
 
-export declare type CaptureSdkSettings = {
-    /** The licence key for loading the Capture SDK. Required. */
-    licenseKey: string;
+export declare type CaptureSdkSettings = Prettify<DirectApiSettings & {
     /** 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.
+ * 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";
 
 /**
@@ -347,10 +373,42 @@ export declare type CaptureStrategy = "optimize-for-speed" | "optimize-for-quali
  */
 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
+ * Completeness status of capture process.
  */
-export declare type CompletnessStatus = "empty" | "one-side-missing" | "complete";
+export declare type CompletenessStatus = "empty" | "one-side-missing" | "complete";
 
 export declare class ConfiguredCamera {
     #private;
@@ -365,95 +423,11 @@ export declare class ConfiguredCamera {
 }
 
 /**
- * Main function that loads the SDK and returns a `captureSdk` object
+ * 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<{
-    /**
-     * 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 function createCaptureSdk(settings: CaptureSdkSettings): Promise<CaptureSdk>;
 
 /**
  * Creates the capture UI and loads the SDK
@@ -469,6 +443,15 @@ declare type CreateCaptureUiSettings = {
     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.
  *
@@ -488,6 +471,8 @@ declare const _default: {
     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;
@@ -518,14 +503,105 @@ declare const _default: {
 };
 
 /**
- * Resets the captureSdk and terminates the workers and the Wasm runtime.
+ * 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.
  */
-declare function destroy(): Promise<void>;
+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";
 
-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";
+/**
+ *  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";
 
 /**
@@ -533,11 +609,19 @@ export declare type DocumentGlareStatus = "not-available" | "glare-detected" | "
  */
 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";
 
-/** Back side analysis */
+/**
+ * Analysis status of the document side for the current frame.
+ */
 export declare type DocumentSideAnalysisStatus = "not-available" | "side-already-captured" | "side-not-captured";
 
 /**
@@ -573,16 +657,13 @@ export declare type ExposedComponentApi = {
     updateLocalization: SetStoreFunction<LocalizationStrings>;
 };
 
-export declare class FeedbackParser {
+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
      */
@@ -597,10 +678,21 @@ export declare class FeedbackParser {
     private getUiStateKeyFromResult;
 }
 
+export declare const feedbackParser: FeedbackParser;
+
+declare const finalizer: unique symbol;
+
 /**
- * Finishes capturing the current side
+ * The return type of `Analyzer.analyze` when an error occurs.
  */
-declare function finishSideCapture(): Promise<void>;
+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.
@@ -612,12 +704,19 @@ declare function finishSideCapture(): Promise<void>;
  * 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;
@@ -681,50 +780,199 @@ export declare type LightingThresholds = {
     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;
 
 /**
- * Pauses the capture process without resetting the recognizer.
+ * 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 function pauseCapture(): void;
+declare type LocalObject<T> = {
+    [P in keyof T]: LocalProperty<T[P]>;
+};
 
 /**
- * Pauses the video playback. This will also stop the capturing process.
+ * 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 function pausePlayback(): void;
+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;
-    /** If Wasm is initialized successfully */
+    /**
+     * 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;
+
 /**
- * Resets the analyzer.
+ * 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 function resetAnalyzer(): Promise<void>;
-
-export declare const resetCoreStore: () => void;
+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;
 
-export declare type ReticleType = "searching" | "processing" | "error" | "done" | "flip";
+/**
+ * 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]>;
+};
 
 /**
- * Select a camera device from available ones.
+ * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
  *
- * @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()}
+ * 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 function selectCamera(camera: ConfiguredCamera): Promise<void>;
+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;
@@ -742,16 +990,6 @@ export declare enum ServerPermissionSubmitResultStatus {
     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>;
@@ -759,12 +997,12 @@ declare type SetStateInternal<T> = {
 }['_'];
 
 /**
- * Result of side capture
+ * Capture result of a single document side.
  */
 export declare type SideCaptureResult = {
     /**
-     * Original image of the captured document, untransformed, as it was used in
-     * analysis.
+     * Original image of the captured document side, untransformed, as it was used
+     * in the analysis.
      */
     imageResult: ImageData;
     /**
@@ -775,33 +1013,16 @@ export declare type SideCaptureResult = {
     /**
      * Document side classification.
      *
-     *  If side classification was uncertain, `"unknown"` is returned.
+     * 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;
 };
 
-/**
- * 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;
@@ -852,30 +1073,30 @@ export declare type UiStateEvent = {
     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 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>>;
 
 /**
- * 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.
+ * 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 function updateAnalyzerSettings(settings: Partial<AnalyzerSettings>): Promise<void>;
+declare type Unpromisify<P> = P extends Promise<infer T> ? T : P;
 
 /**
- * Refreshes available devices on the system and updates the state.
+ * Inverse of `ProxyOrClone<T>`.
  */
-declare function updateCameraDevices(): Promise<void>;
+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 use setters as this will break the application logic. We do not have two-way binding.
- * Make sure you only observe the state.
+ * 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.
  *