@microblink/blinkid-verify-core 3.20.0-rc.0

package/types/index.rollup.d.ts

@@ -0,0 +1,1537 @@
+import { finalizer } from 'comlink';
+import { ProxyMarked } from 'comlink';
+import { Remote } from 'comlink';
+import type { SetOptional } from 'type-fest';
+import type { Simplify } from 'type-fest';
+
+declare type AlertType = "InvalidLicenseKey" | "NetworkError" | "DocumentClassNotAllowed" | "StepTimeout";
+
+/**
+ * Analytic service
+ * Provides a clean interface for tracking user interactions and events
+ */
+export declare class AnalyticService {
+    #private;
+    constructor({ pingFn, sendPingletsFn, }: {
+        pingFn: (ping: Ping) => Promise<void>;
+        sendPingletsFn: () => Promise<void>;
+    });
+    /**
+     * Safely send queued pinglets, handling errors gracefully
+     */
+    sendPinglets(): Promise<void>;
+    logCameraStartedEvent(): Promise<void>;
+    logCameraClosedEvent(): Promise<void>;
+    logHelpOpenedEvent(): Promise<void>;
+    logHelpClosedEvent(contentFullyViewed: boolean): Promise<void>;
+    logHelpTooltipDisplayedEvent(): Promise<void>;
+    logCloseButtonClickedEvent(): Promise<void>;
+    logOnboardingDisplayedEvent(): Promise<void>;
+    logAlertDisplayedEvent(alertType: NonNullable<PingUxEventData["alertType"]>): Promise<void>;
+    logErrorMessageEvent(errorMessageType: PingUxEventData["errorMessageType"]): Promise<void>;
+    logAppMovedToBackgroundEvent(): Promise<void>;
+    logStepTimeoutEvent(): Promise<void>;
+    logCameraInputInfo(pingData: PingCameraInputInfoData): Promise<void>;
+    logHardwareCameraInfo(cameras: PingCameraHardwareInfoData["availableCameras"]): Promise<void>;
+    logCameraPermissionCheck(granted: boolean): Promise<void>;
+    logCameraPermissionRequest(): Promise<void>;
+    logCameraPermissionUserResponse(granted: boolean): Promise<void>;
+    logDeviceOrientation(orientation: PingScanningConditionsData["deviceOrientation"]): Promise<void>;
+    logFlashlightState(flashlightOn: boolean): Promise<void>;
+    logDeviceInfo(pingData: PingBrowserDeviceInfoData): Promise<void>;
+    logErrorEvent({ origin, error, errorType, sessionNumber, }: {
+        origin: string;
+        error: unknown;
+        errorType: PingErrorData["errorType"];
+        sessionNumber?: number;
+    }): Promise<void>;
+}
+
+declare type AvailableCamerasItem = {
+    deviceId: string;
+    cameraFacing: CameraFacing;
+    focus?: Focus;
+    availableResolutions?: AvailableResolutionsItem[];
+};
+
+declare type AvailableResolutionsItem = {
+    width: number;
+    height: number;
+};
+
+/**
+ * Base interface for a scanning session.
+ * All SDK scanning sessions must implement this interface to work with the proxy worker.
+ */
+declare interface BaseScanningSession {
+    /**
+     * Processes an image frame and returns a result.
+     * @param image - The image data to process
+     * @returns The processing result (type varies by SDK)
+     */
+    process: (image: ImageData) => unknown;
+}
+
+/**
+ * Base interface for an SDK worker proxy.
+ * All SDK worker proxies must implement this interface to work with the auto-transfer wrapper.
+ *
+ * Note: The return type can be sync or async (Promise) because Comlink wraps synchronous
+ * methods as async when accessed remotely.
+ */
+declare interface BaseSdkWorkerProxy {
+    /**
+     * Creates a new scanning session.
+     * @param args - Session configuration arguments (varies by SDK)
+     * @returns A scanning session (sync or Promise-wrapped)
+     */
+    createScanningSession: (...args: never[]) => BaseScanningSession | Promise<BaseScanningSession>;
+}
+
+/**
+ * The BlinkIdVerify bindings.
+ *
+ * @ignore
+ */
+export declare interface BlinkIdVerifyBindings extends WasmBindings<BlinkIdVerifySessionSettings, BlinkIdVerifyScanningSession> {
+}
+
+/**
+ * Represents the BlinkIdVerify core instance.
+ *
+ * This type extends the Remote type from Comlink, which is used to proxy calls to the BlinkIdVerify worker.
+ * It simplifies the type to remove unnecessary complexity.
+ */
+export declare type BlinkIdVerifyCore = Simplify<Remote<BlinkIdVerifyWorkerProxy>>;
+
+/**
+ * Configuration options for initializing the BlinkIdVerify core.
+ *
+ * This type extends the BlinkIdVerifyWorkerInitSettings type by making the userId and useLightweightBuild properties optional.
+ * It allows for partial configuration of the initialization settings.
+ */
+export declare type BlinkIdVerifyInitSettings = SetOptional<BlinkIdVerifyWorkerInitSettings, "userId">;
+
+/**
+ * The request payload sent to the BlinkID Verify API.
+ *
+ * Contains the captured document images, verification options, and use-case
+ * configuration derived from the scanning result and session settings.
+ */
+declare type BlinkIdVerifyPayload = {
+    /** The front-side image of the document. */
+    imageFront?: BlinkIdVerifyRequestDocumentVerificationImageSource;
+    /** The back-side image of the document. */
+    imageBack?: BlinkIdVerifyRequestDocumentVerificationImageSource;
+    /** The barcode image extracted from the document. */
+    imageBarcode?: BlinkIdVerifyRequestDocumentVerificationImageSource;
+    /** Verification options that control check strictness and returned data. */
+    options?: {
+        /** Whether an expired document should be treated as fraudulent. */
+        treatExpirationAsFraud?: boolean;
+        /** Controls which parts of the result are anonymized. */
+        anonymizationMode?: BlinkIdVerifyRequestAnonymizationMode;
+        /** How image quality issues affect the overall verification outcome. */
+        imageQualityInterpretation?: BlinkIdVerifyRequestImageQualityInterpretation;
+        /** Match level threshold for detecting that the document was displayed on a screen. */
+        screenMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for detecting photocopy fraud. */
+        photocopyMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for detecting barcode anomalies. */
+        barcodeAnomalyMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for detecting photo forgery. */
+        photoForgeryMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for verifying static security features. */
+        staticSecurityFeaturesMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for data consistency checks across document fields. */
+        dataMatchMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the blur image quality check. */
+        blurMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the glare image quality check. */
+        glareMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the lighting image quality check. */
+        lightingMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the sharpness image quality check. */
+        sharpnessMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the hand occlusion image quality check. */
+        handOcclusionMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the DPI (dots per inch) image quality check. */
+        dpiMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Match level threshold for the document tilt image quality check. */
+        tiltMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+        /** Whether to include the face image in the API response. */
+        returnFaceImage?: boolean;
+        /** Whether to include the full document image in the API response. */
+        returnFullDocumentImage?: boolean;
+        /** Whether to include the signature image in the API response. */
+        returnSignatureImage?: boolean;
+        /** The image format used for returned images. */
+        returnImageFormat?: "Jpg" | "Png" | "Qoi";
+        /** Match level threshold for the generative AI–based fraud detection check. */
+        generativeAiMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+    };
+    /** Use-case configuration that tailors the verification policy to the deployment context. */
+    useCase?: {
+        /** The overall strictness policy applied during document verification. */
+        documentVerificationPolicy?: BlinkIdVerifyRequestDocumentVerificationPolicy;
+        /** The physical context in which the document is being verified. */
+        verificationContext?: BlinkIdVerifyRequestVerificationContext;
+        /** Which verification outcomes are escalated for manual human review. */
+        manualReviewStrategy?: BlinkIdVerifyRequestManualReviewStrategy;
+        /** The sensitivity threshold for triggering manual review. */
+        manualReviewSensitivity?: BlinkIdVerifyRequestManualReviewSensitivity;
+        /** The level of control over image capture conditions. */
+        captureConditions?: BlinkIdVerifyRequestCaptureConditions;
+    };
+    /** The unique identifier of the capture session, used to correlate the request with SDK telemetry. */
+    captureSessionId: string;
+};
+
+/**
+ * Represents the analysis and processing results of an input frame. Provides
+ * real-time feedback on the document's state, identifying any obstacles
+ * preventing successful processing. It also contains extracted data used to
+ * determine the next steps in the scanning workflow.
+ */
+export declare type BlinkIdVerifyProcessResult = {
+    /**
+     * The result of analyzing the frame. Indicating any issues with the currently
+     * processed frame as well as giving some information about the document
+     */
+    inputImageAnalysisResult: InputImageAnalysisResult;
+    /**
+     * Tracking information for the scanning lifecycle. Indicates when the session
+     * has gathered enough data to produce a final result.
+     */
+    resultCompleteness: ResultCompleteness;
+};
+
+/**
+ * Controls which parts of the verification result are anonymized in the API response.
+ *
+ * - `"ImageOnly"` — redacts only the document images.
+ * - `"ResultFieldsOnly"` — redacts only the parsed data fields.
+ * - `"FullResult"` — redacts both images and data fields.
+ * - `"None"` — no anonymization is applied.
+ */
+export declare type BlinkIdVerifyRequestAnonymizationMode = "ImageOnly" | "ResultFieldsOnly" | "FullResult" | "None";
+
+/**
+ * Defines the conditions under which the document is captured as part of the
+ * `UseCase` settings.
+ *
+ * - `"NoControl"`: Is the same as `"Basic"`, it will be removed in
+ *   the future.
+ * - `"Basic"`: Allows for processing of fully cropped documents. The integrator
+ *   has no control over the capture process on the user's side and is limited
+ *   by the lack of a robust SDK. It is not possible for a cropped document to
+ *   get a `Pass` or `Accept` in the overall result. Liveness checks will not be
+ *   performed if the document is fully cropped.
+ * - `"Hybrid"`: Allows for processing of fully cropped documents. The integrator
+ *   has no control over the capture process on the user's side and is limited
+ *   by the lack of a robust SDK. It is possible for a cropped document to get a
+ *   `Pass` or `Accept` in the overall result. Liveness checks will not be
+ *   performed if the document is fully cropped.
+ */
+export declare type BlinkIdVerifyRequestCaptureConditions = "NoControl" | "Basic" | "Hybrid";
+
+/**
+ * Represents a document image submitted to the BlinkID Verify API.
+ */
+declare type BlinkIdVerifyRequestDocumentVerificationImageSource = {
+    /** Base64-encoded JPEG image data, or `null` if no image is available. */
+    base64: string | null;
+};
+
+/**
+ * Defines the strictness of checks performed by BlinkID Verify API as part of the
+ * `UseCase` settings.
+ *
+ * - `"Permissive"`: Optimized for letting real users through. In cases of doubt
+ *   or lower confidence, BlinkID Verify API will avoid failing the document.
+ * - `"Standard"`: Default policy. It is more strict compared to `Permissive` but
+ *   still optimized for accepting real users.
+ * - `"Strict"`: Users with damaged documents, bad lighting conditions or lower
+ *   image quality will probably be rejected. In cases of doubt or lower
+ *   confidence, the document will more often be rejected.
+ * - `"VeryStrict"`: Reasonable only for the most sensitive use cases.
+ *   Significant user friction is added to stop as much fraud as possible.
+ */
+declare type BlinkIdVerifyRequestDocumentVerificationPolicy = "Permissive" | "Standard" | "Strict" | "VeryStrict";
+
+/**
+ * Specifies the strictness of the model when marking the quality of the image.
+ * Includes a range of values that allow for more or less conservative
+ * approach.
+ *
+ * - `"Ignore"`: Ensures that BlinkID Verify API returns a `Pass` or `Fail` verdict
+ *   even if image quality is not good enough.
+ * - `"Conservative"`: If image quality is not good enough, BlinkID Verify API will
+ *   refuse to process the image and a `NotPerformed` verdict will be returned.
+ *   When a `NotPerformed` verdict is returned, BlinkID Verify API will prompt the
+ *   user to repeat the capture process. This is indicated by the `Retry` value
+ *   under `RecommendedOutcome` in the response.
+ * - `"HighAssurance"`: A `Fail` verdict can be returned even if image quality is
+ *   not good enough, but occasionally a `Pass` verdict will not be returned if
+ *   image quality is not satisfactory.
+ * - `"HighConversion"`: A `Pass` verdict can be returned even if image quality
+ *   is not good enough, but occasionally a `Fail` verdict will not be returned
+ *   if image quality is not satisfactory.
+ * - `"VeryHighConversion"`: A `Pass` verdict can be returned even if image
+ *   quality is significantly unsatisfactory, but a `Fail` verdict will not be
+ *   returned if image quality is really poor.
+ */
+export declare type BlinkIdVerifyRequestImageQualityInterpretation = "Ignore" | "Conservative" | "HighAssurance" | "HighConversion" | "VeryHighConversion";
+
+/**
+ * Defines the volume of documents that will be sent for manual review as part
+ * of the `UseCase` settings. The outcome depends on the selected policy and
+ * varies according to the overall verification `CertaintyLevel`.
+ *
+ * If manual review is not used, this setting is ignored.
+ *
+ * - `"Low"`: Only borderline cases are sent for manual review. <br/> Documents
+ *   where certainty is `Low` alongside a `SuspiciousDataCheck` fail will be
+ *   sent for manual review.
+ * - `"Default"`: The manual review process is default.
+ * - `"High"`: The manual review process is high.
+ */
+export declare type BlinkIdVerifyRequestManualReviewSensitivity = "Low" | "Default" | "High";
+
+/**
+ * Defines the manual review strategy used during document verification as part
+ * of the `UseCase` settings.
+ *
+ * - `"Never"`: No documents will be sent for manual review.
+ * - `"RejectedAndAccepted"`: Both rejected and accepted documents will be sent
+ *   for manual review.
+ * - `"RejectedOnly"`: Only rejected documents will be sent for manual review.
+ * - `"AcceptedOnly"`: Only accepted documents will be sent for manual review.
+ */
+export declare type BlinkIdVerifyRequestManualReviewStrategy = "Never" | "RejectedAndAccepted" | "RejectedOnly" | "AcceptedOnly";
+
+/**
+ * Specifies the strictness level for a particular match check sent to the BlinkID Verify Cloud API.
+ *
+ * Higher levels apply stricter thresholds. Use `"Disabled"` to skip a check entirely.
+ */
+export declare type BlinkIdVerifyRequestMatchLevel = "Disabled" | "Level1" | "Level2" | "Level3" | "Level4" | "Level5" | "Level6" | "Level7" | "Level8" | "Level9" | "Level10";
+
+/**
+ * Caller-supplied options for the BlinkID Verify Cloud API request.
+ *
+ * These options are merged with settings derived from the scanning session to
+ * produce the final {@link BlinkIdVerifyPayload}. Only the subset of options
+ * that are relevant to the caller are exposed here.
+ */
+export declare type BlinkIdVerifyRequestOptions = {
+    /** Controls which parts of the result are anonymized in the API response. */
+    anonymizationMode?: BlinkIdVerifyRequestAnonymizationMode;
+    /** Match level threshold for detecting photocopy fraud. */
+    photocopyMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+    /** Match level threshold for detecting photo forgery. */
+    photoForgeryMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+    /** Whether to include the face image in the API response. */
+    returnFaceImage?: boolean;
+    /** Whether to include the full document image in the API response. */
+    returnFullDocumentImage?: boolean;
+    /** Whether to include the signature image in the API response. */
+    returnSignatureImage?: boolean;
+    /** The image format used for returned images. */
+    returnImageFormat?: ReturnImageFormat;
+    /** Match level threshold for the generative AI–based fraud detection check. */
+    generativeAiMatchLevel?: BlinkIdVerifyRequestMatchLevel;
+};
+
+/**
+ * Defines the context under which document verification is performed as part of
+ * the `UseCase` settings. It describes the setup and conditions in which
+ * verification occurs.
+ *
+ * - `"Remote"`: Default policy. Document verification is performed in a remote
+ *   setting where a user is scanning the document in their own space,
+ *   unsupervised.
+ * - `"InPerson"`: Document verification is performed in an in-person environment
+ *   in which a trained employee is scanning the document. <br/> Document
+ *   liveness checks are not performed when `InPerson` policy is set.
+ */
+export declare type BlinkIdVerifyRequestVerificationContext = "Remote" | "InPerson";
+
+/**
+ * Represents the final result of scanning both sides of the document. It
+ * potentially contains the captured frames for the front, back, and barcode.
+ */
+export declare type BlinkIdVerifyScanningResult = EmbindObject_2<{
+    /** The captured frame of the front side of the document, if available. */
+    frontFrame: CapturedFrame | undefined;
+    /** The captured frame of the back side of the document, if available. */
+    backFrame: CapturedFrame | undefined;
+    /** The captured frame of the barcode, if available. */
+    barcodeFrame: CapturedFrame | undefined;
+}>;
+
+/** Represents a scanning session for BlinkID Verify. */
+export declare type BlinkIdVerifyScanningSession = EmbindObject_2<{
+    /**
+     * Processes the given image data.
+     *
+     * @param img The image data to process.
+     * @returns The result of the processing.
+     */
+    process(img: ImageData): BlinkIdVerifyProcessResult;
+    /**
+     * Retrieves the current scanning result.
+     *
+     * @returns The scanning result containing captured frames.
+     */
+    getResult(): BlinkIdVerifyScanningResult;
+    /** Returns the session settings. */
+    getSettings(): BlinkIdVerifySessionSettings;
+    /** Returns the session ID. This info is required for BlinkID Verify Cloud API */
+    getSessionId(): string;
+    /**
+     * Allows the barcode step to be performed during scanning. If during the
+     * scanning process the barcode is unreadable BlinkIdVerifyProcessResult will
+     * return a Scanning status for barcode scanning only.
+     */
+    allowBarcodeStep(): void;
+    /**
+     * Resets the scanning session.
+     *
+     * @returns An error message if reset fails, otherwise undefined.
+     */
+    reset(): void;
+}>;
+
+/** Settings configuring the whole session */
+export declare type BlinkIdVerifySessionSettings = Partial<{
+    /** Defines the source of the input image. */
+    inputImageSource: InputImageSource;
+    /**
+     * Specific settings for the scanning process. If no settings are provided,
+     * defaults will be used.
+     */
+    scanningSettings: ScanningSettings;
+}>;
+
+/**
+ * The BlinkIdVerify Wasm module.
+ *
+ * @ignore
+ */
+export declare interface BlinkIdVerifyWasmModule extends WasmModule<BlinkIdVerifySessionSettings | undefined, BlinkIdVerifyScanningSession> {
+}
+
+/**
+ * The BlinkID Verify worker.
+ */
+export declare class BlinkIdVerifyWorker {
+    #private;
+    /**
+     * The progress status callback.
+     */
+    progressStatusCallback?: ProgressStatusCallback;
+    constructor();
+    reportPinglet({ data, schemaName, schemaVersion, sessionNumber }: Ping): void;
+    sendPinglets(): void;
+    /**
+     * This method initializes everything.
+     */
+    initBlinkIdVerify(settings: BlinkIdVerifyWorkerInitSettings, progressCallback?: ProgressStatusCallback): Promise<void>;
+    /**
+     * This method creates a BlinkIdVerify scanning session.
+     *
+     * @param sessionSettings - The options for the session.
+     * @returns The session.
+     */
+    createScanningSession(sessionSettings?: BlinkIdVerifySessionSettings): WorkerScanningSession & ProxyMarked;
+    /**
+     * This method is called when the worker is terminated.
+     */
+    [finalizer](): void;
+    /**
+     * Terminates the workers and the Wasm runtime.
+     */
+    terminate(): Promise<void>;
+}
+
+/**
+ * Initialization settings for the BlinkIdVerify worker.
+ *
+ * These settings control how the BlinkIdVerify worker is initialized and configured,
+ * including resource locations, memory allocation, and build variants.
+ */
+export declare type BlinkIdVerifyWorkerInitSettings = {
+    /**
+     * The license key required to unlock and use the BlinkIdVerify SDK.
+     * This must be a valid license key obtained from Microblink.
+     */
+    licenseKey: string;
+    /**
+     * The URL of the Microblink proxy server. This proxy handles requests to Microblink's Baltazar and Ping servers.
+     *
+     * **Requirements:**
+     * - Must be a valid HTTPS URL
+     * - The proxy server must implement the expected Microblink API endpoints
+     * - This feature is only available if explicitly permitted by your license
+     *
+     * **Endpoints:**
+     * - Ping: `{proxyUrl}/ping`
+     * - Baltazar: `{proxyUrl}/api/v2/status/check`
+     *
+     * @example "https://your-proxy.example.com"
+     */
+    microblinkProxyUrl?: string;
+    /**
+     * The parent directory where the `/resources` directory is hosted.
+     * Defaults to `window.location.href`, at the root of the current page.
+     */
+    resourcesLocation?: string;
+    /**
+     * A unique identifier for the user/session.
+     * Used for analytics and tracking purposes.
+     */
+    userId: string;
+    /**
+     * The WebAssembly module variant to use.
+     * Different variants may offer different performance/size tradeoffs.
+     */
+    wasmVariant?: WasmSimdVariant;
+    /**
+     * The initial memory allocation for the Wasm module, in megabytes.
+     * Larger values may improve performance but increase memory usage.
+     */
+    initialMemory?: number;
+};
+
+/**
+ * The BlinkIdVerify worker proxy.
+ */
+export declare type BlinkIdVerifyWorkerProxy = Omit<BlinkIdVerifyWorker, typeof finalizer>;
+
+declare type BrandsItem = {
+    brand: string;
+    version: string;
+};
+
+declare type Browser = {
+    brand: string;
+    version: string;
+};
+
+export declare type BrowserStorageSupport = {
+    cookieEnabled: boolean;
+    localStorageEnabled: boolean;
+};
+
+declare type BrowserStorageSupport_2 = {
+    cookieEnabled: boolean;
+    localStorageEnabled: boolean;
+};
+
+declare type CameraFacing = "Front" | "Back" | "Unknown";
+
+declare type CameraFacing_2 = "Front" | "Back" | "Unknown";
+
+/**
+ * Defines the conditions under which the document is captured as part of the
+ * `UseCase` settings.
+ *
+ * - `"no-control"`: _Deprecated_: Is the same as `"basic"`, it will be removed in
+ *   the future.
+ * - `"basic"`: Allows for processing of fully cropped documents. The integrator
+ *   has no control over the capture process on the user's side and is limited
+ *   by the lack of a robust SDK. It is not possible for a cropped document to
+ *   get a `Pass` or `Accept` in the overall result. Liveness checks will not be
+ *   performed if the document is fully cropped.
+ * - `"hybrid"`: Allows for processing of fully cropped documents. The integrator
+ *   has no control over the capture process on the user's side and is limited
+ *   by the lack of a robust SDK. It is possible for a cropped document to get a
+ *   `Pass` or `Accept` in the overall result. Liveness checks will not be
+ *   performed if the document is fully cropped.
+ */
+export declare type CaptureConditions = "no-control" | "basic" | "hybrid";
+
+/** Represents a captured frame */
+export declare interface CapturedFrame {
+    readonly jpegBytes: Uint8Array;
+    orientation: "portrait" | "landscape-left" | "upside-portrait" | "landscape-right";
+}
+
+/**
+ * Options for a C call.
+ *
+ * @ignore
+ */
+export declare interface CCallOpts {
+    async?: boolean | undefined;
+}
+
+export declare function createDerivedDeviceInfo(userAgent: string, userAgentData?: UADataValues): DerivedDeviceInfo;
+
+/**
+ * Creates a Comlink-proxied Web Worker (generic) with automatic ImageData buffer transfer.
+ *
+ * This function wraps the worker proxy to automatically transfer ImageData buffers when calling
+ * `session.process()`, eliminating ~8MB copy per frame during scanning.
+ *
+ * The wrapper intercepts `createScanningSession` and wraps the returned session to auto-transfer
+ * ImageData buffers when `process()` is called. This pattern is common across all Microblink SDKs.
+ *
+ * @param resourcesLocation - Where the "resources" directory is placed.
+ * @param workerScriptName - The worker script filename.
+ * @returns A promise that resolves with a Comlink-proxied instance of the Web Worker.
+ */
+export declare function createProxyWorker<T extends BaseSdkWorkerProxy>(resourcesLocation: string, workerScriptName: string): Promise<Remote<T>>;
+
+export declare type DerivedDeviceInfo = {
+    model: string;
+    formFactors: FormFactor[];
+    platform: string;
+    browser: {
+        brand: string;
+        version: string;
+    };
+};
+
+declare type DerivedDeviceInfo_2 = {
+    model: string;
+    formFactors: FormFactorsItem[];
+    platform: string;
+    browser: Browser;
+};
+
+/** DetectionStatus defines all possible states of detection */
+export declare type DetectionStatus = "failed" | "sucess" | "camera-too-far" | "camera-too-close" | "camera-angle-too-steep" | "document-too-close-to-camera-edge" | "document-partially-visible";
+
+export declare type DeviceInfo = {
+    userAgentData?: UADataValues;
+    userAgent: string;
+    threads: number;
+    memory?: number;
+    gpu?: GpuInfo;
+    screen: DeviceScreenInfo;
+    browserStorageSupport: BrowserStorageSupport;
+    derivedDeviceInfo: DerivedDeviceInfo;
+};
+
+declare type DeviceOrientation = "Portrait" | "LandscapeRight" | "LandscapeLeft" | "PortraitUpside";
+
+export declare type DeviceScreenInfo = {
+    screenWidth: number;
+    screenHeight: number;
+    devicePixelRatio: number;
+    physicalScreenWidth: number;
+    physicalScreenHeight: number;
+    maxTouchPoints: number;
+};
+
+export declare type DocumentOrientation = "not-available" | "horizontal" | "vertical";
+
+export declare type DocumentRotation = "not-available" | "zero" | "clockwise-90" | "counter-clockwise-90" | "upside-down";
+
+/**
+ * Progress reported during a resource download.
+ */
+export declare type DownloadProgress = {
+    loaded: number;
+    contentLength: number;
+    progress: number;
+    finished: boolean;
+};
+
+/**
+ * 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.
+ *
+ * @ignore
+ * @see https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-management for more details.
+ */
+export declare type EmbindObject<T extends {}> = T & {
+    delete: () => void;
+    isDeleted: () => boolean;
+    deleteLater: () => void;
+    isAliasOf: (other: any) => boolean;
+};
+
+/**
+ * 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.
+ *
+ * @see https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#memory-management for more details.
+ */
+declare type EmbindObject_2<T extends NonNullable<unknown>> = T & {
+    /** Free emscripten memory */
+    delete: () => void;
+    /** Check if emscripten memory is freed */
+    isDeleted: () => boolean;
+    /** @ignore */
+    deleteLater: () => void;
+    /** @ignore */
+    isAliasOf: (other: unknown) => boolean;
+    /**
+     * @ignore
+     * @see https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html#cloning-and-reference-counting
+     */
+    clone: () => T;
+};
+
+/**
+ * The main EmscriptenModule interface.
+ *
+ * @ignore
+ */
+export declare interface EmscriptenModule {
+    print(str: string): void;
+    printErr(str: string): void;
+    arguments: string[];
+    environment: EnvironmentType;
+    preInit: Array<{
+        (): void;
+    }>;
+    preRun: Array<{
+        (): void;
+    }>;
+    postRun: Array<{
+        (): void;
+    }>;
+    onAbort: {
+        (what: any): void;
+    };
+    onRuntimeInitialized: {
+        (): void;
+    };
+    preinitializedWebGLContext: WebGLRenderingContext;
+    noInitialRun: boolean;
+    noExitRuntime: boolean;
+    logReadFiles: boolean;
+    filePackagePrefixURL: string;
+    wasmBinary: ArrayBuffer;
+    mainScriptUrlOrBlob?: string;
+    setStatus: (text: string) => void;
+    /**
+     * Allows you to provide your own WebAssembly.Memory to use as the memory. The
+     * properties used to initialize the memory should match the compiler options.
+     * For example, if you set INITIAL_MEMORY to 8MB without memory growth, then
+     * the wasmMemory you provide (if any) should have both the 'initial' and
+     * 'maximum' set to 128 (due to WASM page sizes being 64KB).
+     */
+    wasmMemory: WebAssembly.Memory;
+    destroy(object: object): void;
+    getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer;
+    instantiateWasm(imports: WebAssembly.Imports, successCallback: (module: WebAssembly.Instance) => void): WebAssembly.Exports | undefined;
+    locateFile(url: string, scriptDirectory: string): string;
+    onCustomMessage(event: MessageEvent): void;
+    HEAP: Int32Array;
+    IHEAP: Int32Array;
+    FHEAP: Float64Array;
+    HEAP8: Int8Array;
+    HEAP16: Int16Array;
+    HEAP32: Int32Array;
+    HEAPU8: Uint8Array;
+    HEAPU16: Uint16Array;
+    HEAPU32: Uint32Array;
+    HEAPF32: Float32Array;
+    HEAPF64: Float64Array;
+    HEAP64: BigInt64Array;
+    HEAPU64: BigUint64Array;
+    TOTAL_STACK: number;
+    TOTAL_MEMORY: number;
+    FAST_MEMORY: number;
+    addOnPreRun(cb: () => any): void;
+    addOnInit(cb: () => any): void;
+    addOnPreMain(cb: () => any): void;
+    addOnExit(cb: () => any): void;
+    addOnPostRun(cb: () => any): void;
+    preloadedImages: any;
+    preloadedAudios: any;
+    _malloc(size: number): number;
+    _free(ptr: number): void;
+}
+
+/**
+ * A factory function is generated when setting the `MODULARIZE` build option to
+ * `1` in your Emscripten build. It return a Promise that resolves to an
+ * initialized, ready-to-call `EmscriptenModule` instance.
+ *
+ * By default, the factory function will be named `Module`. It's recommended to
+ * use the `EXPORT_ES6` option, in which the factory function will be the
+ * default export. If used without `EXPORT_ES6`, the factory function will be a
+ * global variable. You can rename the variable using the `EXPORT_NAME` build
+ * option. It's left to you to declare any global variables as needed in your
+ * application's types.
+ *
+ * @ignore
+ * @param moduleOverrides Default properties for the initialized module.
+ */
+export declare type EmscriptenModuleFactory<T extends EmscriptenModule = EmscriptenModule> = (moduleOverrides?: Partial<T>) => Promise<T>;
+
+/**
+ * The environment type.
+ *
+ * @ignore
+ */
+export declare type EnvironmentType = "WEB" | "NODE" | "SHELL" | "WORKER";
+
+declare type ErrorMessageType = "MoveCloser" | "MoveFarther" | "KeepVisible" | "FlipSide" | "AlignDocument" | "MoveFromEdge" | "IncreaseLighting" | "DecreaseLighting" | "EliminateBlur" | "EliminateGlare";
+
+declare type ErrorType = "NonFatal" | "Crash";
+
+declare type EventType = "CameraPermissionCheck" | "CameraPermissionRequest" | "CameraPermissionUserResponse";
+
+declare type EventType_2 = "CameraStarted" | "CameraClosed" | "OnboardingInfoDisplayed" | "CloseButtonClicked" | "HelpTooltipDisplayed" | "HelpOpened" | "HelpClosed" | "AlertDisplayed" | "ErrorMessage" | "StepTimeout" | "AppMovedToBackground";
+
+declare type Focus = "Auto" | "Fixed";
+
+/**
+ * Common form-factor values as per spec.
+ *
+ * @see https://wicg.github.io/ua-client-hints/#sec-ch-ua-form-factors
+ */
+export declare type FormFactor = "Desktop" | "Automotive" | "Mobile" | "Tablet" | "XR" | "EInk" | "Watch";
+
+declare type FormFactorsItem = "Desktop" | "Automotive" | "Mobile" | "Tablet" | "XR" | "EInk" | "Watch";
+
+declare type FullVersionListItem = {
+    brand: string;
+    version: string;
+};
+
+/**
+ * Builds the JSON payload for the BlinkID Verify Cloud API from a completed scanning result.
+ *
+ * Maps internal SDK enum values (kebab-case) to their API-facing PascalCase equivalents
+ * and encodes captured document frames as base64 JPEG strings.
+ *
+ * @param result - The scanning result produced by the BlinkIdVerify SDK.
+ * @param sessionId - The unique identifier of the capture session to include in the payload.
+ * @param settings - The scanning settings used during the session, used to derive verification options.
+ * @param options - Optional caller-supplied overrides for anonymization, image return, and match levels.
+ * @returns The fully constructed payload ready to be submitted to the BlinkID Verify Cloud API.
+ */
+export declare function GeneratePayloadForBlinkidVerifyRequest(result: BlinkIdVerifyScanningResult, sessionId: string, settings: ScanningSettings, options?: BlinkIdVerifyRequestOptions): BlinkIdVerifyPayload;
+
+/**
+ * Gets a cross-origin worker URL as a data URL or blob URL. If the URL is same-origin, it will return the original URL.
+ *
+ * @param originalWorkerUrl - The original worker URL.
+ * @param _options - The options for the worker.
+ * @returns A promise that resolves with the cross-origin worker URL.
+ */
+export declare const getCrossOriginWorkerURL: (originalWorkerUrl: string, _options?: Options) => Promise<string>;
+
+export declare function getDeviceInfo(): Promise<DeviceInfo>;
+
+/**
+ * Get granular device info from `navigator.userAgentData.getHighEntropyValues`
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData/getHighEntropyValues
+ */
+export declare function getUserAgentData(): Promise<UADataValues | undefined>;
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+/**
+ * Gets the user id from local storage, or generates a new one.
+ *
+ * This is a workaround for the lack of a user id in the worker scope.
+ *
+ * @param storageKey - The localStorage key to use for persisting the user id.
+ * @returns a unique user id
+ */
+export declare function getUserId(storageKey: string): string;
+
+declare type Gpu = {
+    renderer: string;
+    shadingLanguageVersion: string;
+    vendor: string;
+    version: string;
+};
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getParameter
+ */
+export declare type GpuInfo = {
+    renderer: string;
+    shadingLanguageVersion: string;
+    vendor: string;
+    version: string;
+};
+
+declare type HelpCloseType = "ContentSkipped" | "ContentFullyViewed";
+
+/**
+ * Specifies the strictness of the model when marking the quality of the image.
+ * Includes a range of values that allow for more or less conservative
+ * approach.
+ *
+ * - `"ignore"`: Ensures that BlinkID Verify returns a `Pass` or `Fail` verdict
+ *   even if image quality is not good enough.
+ * - `"conservative"`: If image quality is not good enough, BlinkID Verify will
+ *   refuse to process the image and a `NotPerformed` verdict will be returned.
+ *   When a `NotPerformed` verdict is returned, BlinkID Verify will prompt the
+ *   user to repeat the capture process. This is indicated by the `Retry` value
+ *   under `RecommendedOutcome` in the response.
+ * - `"high-assurance"`: A `Fail` verdict can be returned even if image quality is
+ *   not good enough, but occasionally a `Pass` verdict will not be returned if
+ *   image quality is not satisfactory.
+ * - `"high-conversion"`: A `Pass` verdict can be returned even if image quality
+ *   is not good enough, but occasionally a `Fail` verdict will not be returned
+ *   if image quality is not satisfactory.
+ * - `"very-high-conversion"`: A `Pass` verdict can be returned even if image
+ *   quality is significantly unsatisfactory, but a `Fail` verdict will not be
+ *   returned if image quality is really poor.
+ */
+export declare type ImageQualityInterpretation = "ignore" | "conservative" | "high-assurance" | "high-conversion" | "very-high-conversion";
+
+/**
+ * Options for image quality settings. Stricter settings will provide better
+ * quality images as the scan will not complete until they are met. If not
+ * defined internal defaults will be used.
+ */
+export declare type ImageQualitySettings = Partial<{
+    /**
+     * Threshold for detecting blur on the document. Higher levels provide
+     * stricter requirements.
+     */
+    blurMatchLevel: MatchLevel;
+    /**
+     * Threshold for detecting glare on the document. Higher levels provide
+     * stricter requirements.
+     */
+    glareMatchLevel: MatchLevel;
+    /**
+     * Threshold for expected lighting level of a document on screen. Higher
+     * levels provide stricter requirements.
+     */
+    lightingMatchLevel: MatchLevel;
+    /**
+     * Threshold for detecting the sharpness of the document. Higher levels
+     * provide stricter requirements.
+     */
+    sharpnessMatchLevel: MatchLevel;
+    /**
+     * Threshold for detecting hand occlusion on the document. Higher levels
+     * provide stricter requirements.
+     */
+    handOcclusionMatchLevel: MatchLevel;
+    /**
+     * Threshold for detecting the DPI of the document. Higher levels provide
+     * stricter requirements.
+     */
+    dpiMatchLevel: MatchLevel;
+    /**
+     * Threshold for detecting the tilt of the document in screen. Higher levels
+     * provide stricter requirements.
+     */
+    tiltMatchLevel: MatchLevel;
+    /**
+     * Specifies the strictness of the model when marking the quality of the
+     * image. Includes a range of values that allow for more or less conservative
+     * approach.
+     */
+    interpretation: ImageQualityInterpretation;
+}>;
+
+export declare type InputImageAnalysisResult = {
+    blurDetected: boolean;
+    glareDetected: boolean;
+    occlusionDetected: boolean;
+    tiltDetected: boolean;
+    hasBarcodeReadingIssue: boolean;
+    /** Information extracted from the currently processed frame */
+    extractionInputImageAnalysisResult: {
+        /** The location of the document quadrilateral in the frame. */
+        documentLocation: Quadrilateral;
+        /**
+         * The status of the processing. Beeing either `success` or a potential
+         * `issue in the scannign process`
+         */
+        processingStatus: ProcessingStatus;
+        /**
+         * The status of the detection. This status is used for guidance of the
+         * document placement. Giving instructions to the user on how to position
+         * the document in the frame.
+         */
+        detectionStatus: DetectionStatus;
+        /** Categorieses the document as a passport */
+        isPassport: boolean;
+        /** Categorieses the document as a passport with barcode */
+        isPassportWithBarcode: boolean;
+        documentOrientation: DocumentOrientation;
+        documentRotation: DocumentRotation;
+    };
+};
+
+/**
+ * The source of the input image.
+ *
+ * - `photo`: A single image will be provided to the sdk for analysis per side of
+ *   document. This feature is currently not supported.
+ * - `video`: A consecutive stream of images will be provided to the sdk.
+ */
+export declare type InputImageSource = "photo" | "video";
+
+/** The license request. */
+export declare type LicenseRequest = Readonly<{
+    /** The license id. */
+    licenseId: string;
+    /** The licensee. */
+    licensee: string;
+    /** The application ids. */
+    applicationIds: Array<string>;
+    /** The package name. */
+    packageName: string;
+    /** The platform. */
+    platform: string;
+    /** The sdk name. */
+    sdkName: string;
+    /** The sdk version. */
+    sdkVersion: string;
+}>;
+
+/** The license token state. */
+export declare type LicenseTokenState = "invalid" | "requires-server-permission" | "valid";
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+/** The license unlock result. */
+export declare type LicenseUnlockResult = Readonly<{
+    /** Whether the license is a trial license. */
+    isTrial: boolean;
+    /** Whether the license has ping enabled. */
+    hasPing: boolean;
+    /** The license id. */
+    licenseId: string;
+    /** The licensee. */
+    licensee: string;
+    /** The application ids. */
+    applicationIds: Array<string>;
+    /** The package name. */
+    packageName: string;
+    /** The sdk name. */
+    sdkName: string;
+    /** The sdk version. */
+    sdkVersion: string;
+    /** The unlock result. */
+    unlockResult: LicenseTokenState;
+    /** The license error. */
+    licenseError: string;
+    /** Whether to show the demo overlay. */
+    showDemoOverlay: boolean;
+    /** Whether to show the production overlay. */
+    showProductionOverlay: boolean;
+    /** Whether to allow baltazar proxy. */
+    allowBaltazarProxy: boolean;
+    /** Whether to allow ping proxy. */
+    allowPingProxy: boolean;
+}>;
+
+/**
+ * Creates and initializes a BlinkIdVerify core instance.
+ *
+ * @param settings - Configuration for BlinkIdVerify initialization including license key and resources location
+ * @param progressCallback - Optional callback for tracking resource download progress (WASM, data files)
+ * @returns Promise that resolves with initialized BlinkIdVerify core instance
+ * @throws Error if initialization fails
+ */
+export declare function loadBlinkIdVerifyCore(settings: BlinkIdVerifyInitSettings, progressCallback?: ProgressStatusCallback): Promise<BlinkIdVerifyCore>;
+
+/**
+ * The load Wasm params.
+ */
+export declare type LoadWasmParams = {
+    resourceUrl: string;
+    wasmVariant: WasmSimdVariant;
+    initialMemory?: number;
+};
+
+declare type LogLevel = "Info" | "Warning";
+
+/**
+ * Defines the volume of documents that will be sent for manual review as part
+ * of the `UseCase` settings. The outcome depends on the selected policy and
+ * varies according to the overall verification `CertaintyLevel`.
+ *
+ * If manual review is not used, this setting is ignored.
+ *
+ * - `"low"`: Only borderline cases are sent for manual review. <br/> Documents
+ *   where certainty is `Low` alongside a `SuspiciousDataCheck` fail will be
+ *   sent for manual review.
+ * - `"default"`: The manual review process is default.
+ * - `"high"`: The manual review process is high.
+ */
+export declare type ManualReviewSensitivity = "low" | "default" | "high";
+
+/**
+ * Defines the manual review strategy used during document verification as part
+ * of the `UseCase` settings.
+ *
+ * - `"never"`: No documents will be sent for manual review.
+ * - `"rejected-and-accepted"`: Both rejected and accepted documents will be sent
+ *   for manual review.
+ * - `"rejected-only"`: Only rejected documents will be sent for manual review.
+ * - `"accepted-only"`: Only accepted documents will be sent for manual review.
+ */
+export declare type ManualReviewStrategy = "never" | "rejected-and-accepted" | "rejected-only" | "accepted-only";
+
+/**
+ * Represents the level of strictness for a matching check during the document
+ * verification process. This enum defines the different levels that can be
+ * configured for various checks, such as photocopy or barcode anomaly
+ * detection. Higher levels indicate stricter requirements, leading to fewer
+ * false positives but potentially more false negatives.
+ *
+ * - `"disabled"`: The matching check is disabled, that check will not be
+ *   performed.
+ * - `"level-1" to "level-10"`: Increasing levels of strictness, from least to
+ *   most strict.
+ */
+export declare type MatchLevel = "disabled" | "level-1" | "level-2" | "level-3" | "level-4" | "level-5" | "level-6" | "level-7" | "level-8" | "level-9" | "level-10";
+
+/**
+ * @see https://wicg.github.io/ua-client-hints/#dictdef-navigatoruabrandversion
+ */
+declare interface NavigatorUABrandVersion {
+    readonly brand: string;
+    readonly version: string;
+}
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+/**
+ * Options for the getCrossOriginWorkerURL function.
+ *
+ * @param skipSameOrigin - If true, the function will return the original URL if it is same-origin.
+ * @param useBlob - If true, the function will return a blob URL.
+ */
+declare type Options = {
+    /** If true, the function will return the original URL if it is same-origin. */
+    skipSameOrigin?: boolean;
+    /** If true, the function will return a blob URL if not same-origin. */
+    useBlob?: boolean;
+};
+
+export declare type Ping = PingBrowserDeviceInfo | PingError | PingCameraHardwareInfo | PingLog | PingCameraInputInfo | PingCameraPermission | PingSdkInitStart | PingScanningConditions | PingUxEvent | PingWrapperProductInfo;
+
+/** Generated base structure for a ping event. */
+export declare interface PingBase<TSchemaName extends SchemaName, TSchemaVersion extends Semver = "1.0.0", TData extends object = {}, TSessionNumber extends number = number> {
+    schemaName: TSchemaName;
+    schemaVersion: TSchemaVersion;
+    data: TData;
+    sessionNumber?: TSessionNumber;
+}
+
+/**
+ * Ping type for ping.browser.device.info
+ */
+export declare type PingBrowserDeviceInfo = PingBase<"ping.browser.device.info", "1.0.0", PingBrowserDeviceInfoData>;
+
+export declare type PingBrowserDeviceInfoData = {
+    userAgentData?: UserAgentData;
+    userAgent: string;
+    threads: number;
+    memory?: number;
+    gpu?: Gpu;
+    screen: Screen_2;
+    browserStorageSupport: BrowserStorageSupport_2;
+    derivedDeviceInfo: DerivedDeviceInfo_2;
+};
+
+/**
+ * Ping type for ping.hardware.camera.info
+ */
+export declare type PingCameraHardwareInfo = PingBase<"ping.hardware.camera.info", "1.0.3", PingCameraHardwareInfoData>;
+
+export declare type PingCameraHardwareInfoData = {
+    availableCameras: AvailableCamerasItem[];
+};
+
+/**
+ * Ping type for ping.sdk.camera.input.info
+ */
+export declare type PingCameraInputInfo = PingBase<"ping.sdk.camera.input.info", "1.0.2", PingCameraInputInfoData>;
+
+export declare type PingCameraInputInfoData = {
+    deviceId: string;
+    cameraFacing: CameraFacing_2;
+    cameraFrameWidth: number;
+    cameraFrameHeight: number;
+    roiWidth: number;
+    roiHeight: number;
+    viewPortAspectRatio: number;
+};
+
+/**
+ * Ping type for ping.sdk.camera.permission
+ */
+export declare type PingCameraPermission = PingBase<"ping.sdk.camera.permission", "1.0.0", PingCameraPermissionData>;
+
+export declare type PingCameraPermissionData = {
+    eventType: EventType;
+    cameraPermissionGranted?: boolean;
+};
+
+/**
+ * Ping type for ping.error
+ */
+export declare type PingError = PingBase<"ping.error", "1.0.0", PingErrorData>;
+
+export declare type PingErrorData = {
+    errorType: ErrorType;
+    errorMessage: string;
+    stackTrace?: string;
+};
+
+/**
+ * Ping type for ping.log
+ */
+export declare type PingLog = PingBase<"ping.log", "1.0.0", PingLogData>;
+
+export declare type PingLogData = {
+    logLevel: LogLevel;
+    logMessage: string;
+};
+
+/**
+ * Ping type for ping.sdk.scan.conditions
+ */
+export declare type PingScanningConditions = PingBase<"ping.sdk.scan.conditions", "1.0.0", PingScanningConditionsData>;
+
+export declare type PingScanningConditionsData = {
+    updateType: UpdateType;
+    deviceOrientation?: DeviceOrientation;
+    flashlightOn?: boolean;
+};
+
+/**
+ * Ping type for ping.sdk.init.start
+ */
+export declare type PingSdkInitStart = PingBase<"ping.sdk.init.start", "1.1.0", PingSdkInitStartData>;
+
+export declare type PingSdkInitStartData = {
+    product: Product;
+    platform: Platform;
+    platformDetails?: PlatformDetails;
+    packageName: string;
+    userId: string;
+};
+
+/**
+ * Ping type for ping.sdk.ux.event
+ */
+export declare type PingUxEvent = PingBase<"ping.sdk.ux.event", "1.0.0", PingUxEventData>;
+
+export declare type PingUxEventData = {
+    eventType: EventType_2;
+    errorMessageType?: ErrorMessageType;
+    alertType?: AlertType;
+    helpCloseType?: HelpCloseType;
+};
+
+/**
+ * Ping type for ping.sdk.wrapper.product
+ */
+export declare type PingWrapperProductInfo = PingBase<"ping.sdk.wrapper.product", "1.0.0", PingWrapperProductInfoData>;
+
+export declare type PingWrapperProductInfoData = {
+    wrapperProduct: WrapperProduct;
+    correlationId?: string;
+};
+
+declare type Platform = "iOS" | "Android" | "Emscripten" | "MacOS" | "Linux" | "Windows";
+
+declare type PlatformDetails = "basic" | "advanced" | "advanced-threads" | "full-basic" | "full-advanced" | "full-advanced-threads" | "lightweight-basic" | "lightweight-advanced" | "lightweight-advanced-threads";
+
+/** Represents a point in 2D space. */
+export declare type Point = {
+    x: number;
+    y: number;
+};
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+/**
+ * Represents the status of the document processing. This enum defines various
+ * statuses that can occur during the processing of a document, indicating the
+ * success or failure of different stages of the recognition and extraction
+ * process.
+ */
+export declare type ProcessingStatus = "success" | "detection-failed" | "image-preprocessing-failed" | "stability-test-failed" | "scanning-wrong-side" | "field-identification-failed" | "mandatory-field-missing" | "invalid-characters-found" | "image-return-failed" | "barcode-recognition-failed" | "mrz-parsing-failed" | "document-filtered" | "unsupported-document" | "awaiting-other-side" | "not-scanned" | "barcode-detection-failed";
+
+/**
+ * The process result with buffer.
+ */
+export declare type ProcessResultWithBuffer = BlinkIdVerifyProcessResult & {
+    arrayBuffer: ArrayBuffer;
+};
+
+declare type Product = "BlinkCard" | "BlinkID" | "BlinkInput" | "Capture" | "DocumentVerification" | "Pdf417Mobi" | "PhotoPay";
+
+/**
+ * The progress status callback.
+ */
+export declare type ProgressStatusCallback = (progress: DownloadProgress) => void;
+
+/** Represents a Quadrilateral */
+export declare type Quadrilateral = {
+    upperLeft: Point;
+    upperRight: Point;
+    lowerLeft: Point;
+    lowerRight: Point;
+};
+
+/** Represents a remote scanning session. */
+export declare type RemoteScanningSession = Remote<WorkerScanningSession>;
+
+/**
+ * Removes the internals of an Embind object.
+ *
+ * @ignore
+ * @param T - The type of the object to remove the internals from.
+ * @returns The object with the internals removed.
+ */
+export declare type RemoveEmbindInternals<T> = Omit<T, "delete" | "isDeleted" | "deleteLater" | "isAliasOf">;
+
+export declare type ResourceFileType = (typeof resourceFileTypes)[number];
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+export declare const resourceFileTypes: readonly ["wasm", "data"];
+
+export declare type ResultCompleteness = {
+    /**
+     * The current phase of the scanning state machine, driving the progression
+     * toward session completion.
+     */
+    scanningStatus: ScanningStatus;
+};
+
+/**
+ * The image format used when requesting document images in the API response.
+ */
+export declare type ReturnImageFormat = "Jpg" | "Png" | "Qoi";
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+/** Represents the configurable settings for scanning a document. */
+export declare type ScanningSettings = Partial<{
+    /** Whether to treat expired documents as fraudulent. */
+    treatExpirationAsFraud: boolean;
+    /**
+     * Threshold for detecting screen-displayed documents. Higher levels provide
+     * stricter detection.
+     */
+    screenAnalysisMatchLevel: MatchLevel;
+    /**
+     * Threshold for verifying static security features. Higher levels require
+     * more security features to be present.
+     */
+    staticSecurityFeaturesMatchLevel: MatchLevel;
+    /**
+     * Threshold for detecting anomalies in document barcodes. Higher levels
+     * provide stricter detection.
+     */
+    barcodeAnomalyMatchLevel: MatchLevel;
+    /**
+     * Threshold for matching data between different parts of the document. Higher
+     * levels require closer matches.
+     */
+    dataMatchMatchLevel: MatchLevel;
+    /** Defines the settings for image quality. */
+    imageQualitySettings: ImageQualitySettings;
+    /** Defines the use case for the scanning process. */
+    useCase: UseCase;
+}>;
+
+/**
+ * Defines the progression of the scanning state machine. This status determines
+ * the instructions and visual cues displayed to the user throughout the
+ * multi-step scanning sequence.
+ */
+export declare type ScanningStatus = "scanning-first" | "scanned-first" | "scanning-second" | "scanned-second" | "scanning-barcode" | "document-scanned" | "cancelled";
+
+export declare type SchemaName = Ping["schemaName"];
+
+declare type Screen_2 = {
+    screenWidth: number;
+    screenHeight: number;
+    devicePixelRatio: number;
+    physicalScreenWidth: number;
+    physicalScreenHeight: number;
+    maxTouchPoints: number;
+};
+
+declare type Semver = `${number}.${number}.${number}` | `${number}.${number}.${number}-${string}`;
+
+/** The server permission error. */
+export declare type ServerPermissionErrorReason = "network-error" | "remote-lock" | "permission-expired" | "payload-corrupted" | "payload-signature-verification-failed" | "incorrect-token-state" | "detected-skewed-clock";
+
+/** The server permission submit error. */
+export declare type ServerPermissionSubmitError = Readonly<{
+    /** The error. */
+    error: ServerPermissionErrorReason;
+    /** The lease. */
+    lease: number;
+    /** The network error description. */
+    networkErrorDescription?: string;
+}>;
+
+/**
+ * @see https://wicg.github.io/ua-client-hints/#dictdef-uadatavalues
+ */
+export declare interface UADataValues {
+    readonly brands?: NavigatorUABrandVersion[];
+    readonly mobile?: boolean;
+    readonly platform?: string;
+    readonly architecture?: string;
+    readonly bitness?: string;
+    readonly formFactors?: FormFactor[];
+    readonly model?: string;
+    readonly platformVersion?: string;
+    /** @deprecated in favour of fullVersionList */
+    readonly uaFullVersion?: string;
+    readonly fullVersionList?: NavigatorUABrandVersion[];
+    readonly wow64?: boolean;
+}
+
+declare type UpdateType = "DeviceOrientation" | "FlashlightState";
+
+export declare type UseCase = Partial<{
+    /**
+     * The strictness policy that defines the rules and requirements for document
+     * verification
+     */
+    verificationPolicy: VerificationPolicy;
+    /** The strategy for handling manual reviews of documents, if required. */
+    manualReviewStrategy: ManualReviewStrategy;
+    /** The level of sensitivity applied to the manual review process */
+    manualReviewSensitivity: ManualReviewSensitivity;
+    /** The context of the verification, done either in-person or remote. */
+    verificationContext: VerificationContext;
+    /** The conditions under which the document is being captured. */
+    captureConditions: CaptureConditions;
+}>;
+
+declare type UserAgentData = {
+    brands?: BrandsItem[];
+    mobile?: boolean;
+    platform?: string;
+    architecture?: string;
+    bitness?: string;
+    formFactors?: FormFactorsItem[];
+    model?: string;
+    platformVersion?: string;
+    fullVersionList?: FullVersionListItem[];
+    wow64?: boolean;
+};
+
+/**
+ * Defines the context under which document verification is performed as part of
+ * the `UseCase` settings. It describes the setup and conditions in which
+ * verification occurs.
+ *
+ * - `"remote"`: Default policy. Document verification is performed in a remote
+ *   setting where a user is scanning the document in their own space,
+ *   unsupervised.
+ * - `"in-person"`: Document verification is performed in an in-person environment
+ *   in which a trained employee is scanning the document. <br/> Document
+ *   liveness checks are not performed when `InPerson` policy is set.
+ */
+export declare type VerificationContext = "remote" | "in-person";
+
+/**
+ * Defines the strictness of checks performed by BlinkID Verify as part of the
+ * `UseCase` settings.
+ *
+ * - `"permissive"`: Optimized for letting real users through. In cases of doubt
+ *   or lower confidence, BlinkID Verify will avoid failing the document.
+ * - `"standard"`: Default policy. It is more strict compared to `Permissive` but
+ *   still optimized for accepting real users.
+ * - `"strict"`: Users with damaged documents, bad lighting conditions or lower
+ *   image quality will probably be rejected. In cases of doubt or lower
+ *   confidence, the document will more often be rejected.
+ * - `"very-strict"`: Reasonable only for the most sensitive use cases.
+ *   Significant user friction is added to stop as much fraud as possible.
+ */
+export declare type VerificationPolicy = "permissive" | "standard" | "strict" | "very-strict";
+
+export declare interface WasmBindings<TSessionSettings, TScanningSession> {
+    createScanningSession: (sessionSettings: TSessionSettings, userId: string) => TScanningSession;
+    initializeWithLicenseKey: (licenceKey: string, userId: string, allowHelloMessage: boolean) => LicenseUnlockResult;
+    submitServerPermission: (serverPermission: string) => ServerPermissionSubmitError | undefined;
+    getActiveLicenseTokenInfo: () => LicenseUnlockResult;
+    setPingProxyUrl: (url: string) => void;
+    initializeSdk: (userId: string) => void;
+    terminateSdk: () => void;
+    sendPinglets: () => void;
+    arePingRequestsInProgress: () => boolean;
+    queuePinglet: (data: string, schemaName: string, schemaVersion: string, sessionNumber: number) => void;
+    isPingEnabled: () => boolean;
+}
+
+export declare type WasmBuildType = (typeof wasmBuildTypes)[number];
+
+export declare const wasmBuildTypes: readonly ["full", "lightweight"];
+
+export declare interface WasmModule<TSessionSettings, TScanningSession> extends WasmBindings<TSessionSettings, TScanningSession>, EmscriptenModule {
+}
+
+export declare type WasmSimdVariant = (typeof wasmSimdVariants)[number];
+
+export declare const wasmSimdVariants: readonly ["advanced", "advanced-threads"];
+
+export declare type WasmVariant = (typeof wasmVariants)[number];
+
+export declare const wasmVariants: readonly ["basic", "advanced", "advanced-threads"];
+
+/**
+ * Copyright (c) 2026 Microblink Ltd. All rights reserved.
+ */
+/**
+ * The WebAssembly module, for compatibility.
+ *
+ * @ignore
+ */
+export declare interface WebAssemblyModule {
+}
+
+/**
+ * The worker scanning session.
+ */
+export declare type WorkerScanningSession = Omit<BlinkIdVerifyScanningSession, "process" | "deleteLater" | "isAliasOf" | "clone"> & {
+    process: (image: ImageData) => ProcessResultWithBuffer;
+    /**
+     * Gets the settings.
+     *
+     * @returns The settings.
+     */
+    getSettings: () => BlinkIdVerifySessionSettings;
+    /**
+     * Shows the demo overlay.
+     *
+     * @returns Whether the demo overlay is shown.
+     */
+    showDemoOverlay: () => boolean;
+    /**
+     * Shows the production overlay.
+     *
+     * @returns Whether the production overlay is shown.
+     */
+    showProductionOverlay: () => boolean;
+    ping: BlinkIdVerifyWorker["reportPinglet"];
+    sendPinglets: BlinkIdVerifyWorker["sendPinglets"];
+};
+
+declare type WrapperProduct = "CrossplatformFlutter" | "CrossplatformReactNative" | "IdentityVerification";
+
+export { }