scanbot-web-sdk 6.0.0-dev.1 → 6.0.0-dev.3

package/@types/core/worker/ScanbotSDK.Core.d.ts

@@ -0,0 +1,86 @@
+import { PdfConfig } from "../bridge/compiled/PdfConfig";
+import { type RecognitionResult as MrzRecognitionResult, RecognizerConfiguration as MrzRecognizerConfig } from "../bridge/compiled/MRZTypes";
+import { Config as DqaConfig, type AnalysisResult as DqaAnalysisResult } from "../bridge/compiled/DocumentQualityAnalyzerTypes";
+import { ParametricFilter } from "../bridge/compiled/ParametricFilters";
+import type { ImageRotation } from "../bridge/compiled/ImageProcessorTypes";
+import { DetectionParameters, type DetectionResult } from "../bridge/compiled/DocumentDetectorTypes";
+import { ScannerConfiguration as GtsConfig, type ScannerResult as GtsResult } from "../bridge/compiled/GenericTextLineScannerTypes";
+import type { Page } from "../bridge/compiled/OcrElements";
+import { type BarcodeDocumentFormat, BarcodeRecognizerParameters, type BarcodeScannerResult } from "../bridge/compiled/BarcodeScannerTypes";
+import { GenericDocumentRecognizerParameters, RecognitionParameters as GdrRecognitionParameters, type RecognitionResult as GdrRecognitionResult } from "../bridge/compiled/GenericDocumentRecognizerTypes";
+import { type Binarize, TIFFWriterParameters } from "../bridge/compiled/TiffTypes";
+import type { RawImage, Point, DeepPartial } from "../bridge/common";
+import type { GenericDocument } from "../bridge/compiled/GenericDocument";
+/** Represents an object of type T residing in the WASM's memory. */
+export declare class ObjectId<T> {
+    readonly id: string;
+    /** @internal */
+    readonly _type?: T;
+    constructor(id: string);
+}
+/**
+ * Represents an image in a format that can be consumed by the WASM module.
+ * That is
+ *   - either an ImageData object,
+ *   - an ArrayBuffer or Uint8Array containing the binary data of an encoded image (most common image formats such as PNG and JPEG are supported),
+ *   - or a RawImage, which are obtained by several SDK functions.
+ * */
+export type Image = ImageData | ArrayBuffer | Uint8Array | RawImage;
+type InitializeOptions = {
+    captureConsole?: boolean;
+    allowThreads?: boolean;
+    jpegQuality?: number;
+    requestSuffix?: string;
+};
+export declare const commands: {
+    initialize: (licenseKey?: string, engine?: string, appId?: string, cdnPath?: string, options?: InitializeOptions) => Promise<any>;
+    getLicenseInfo: () => Promise<any>;
+    encodeJpeg: (image: Image) => Promise<Uint8Array>;
+    detectDocument: (image: Image, options: DeepPartial<DetectionParameters>) => Promise<DetectionResult>;
+    detectAndCropDocument: (image: Image) => Promise<CroppedDetectionResult>;
+    createDocumentDetector: (options: DeepPartial<DetectionParameters>) => Promise<ObjectId<"DocumentDetector">>;
+    documentDetectorDetect: <ImageType extends Image>(documentDetectorToken: ObjectId<"DocumentDetector">, image: ImageType) => Promise<DetectionResult & {
+        originalImage: ImageType;
+    }>;
+    parseBarcodeDocument: (options: BarcodeDocumentFormat[], data: string) => Promise<GenericDocument | null>;
+    createBarcodeRecognizer: (options: DeepPartial<BarcodeRecognizerParameters>) => Promise<ObjectId<"BarcodeRecognizer">>;
+    recognizeBarcodes: <ImageType_1 extends Image>(barcodeRecognizerToken: ObjectId<"BarcodeRecognizer">, image: ImageType_1) => Promise<BarcodeScannerResult & {
+        originalImage: ImageType_1;
+    }>;
+    beginPdf: (options: DeepPartial<PdfConfig>) => Promise<ObjectId<"PdfGenerationContext">>;
+    addPageToPdf: (pdfOperation: ObjectId<"PdfGenerationContext">, image: Image) => Promise<void>;
+    completePdf: (pdfOperation: ObjectId<"PdfGenerationContext">) => Promise<Uint8Array>;
+    beginTiff: (options: DeepPartial<TIFFWriterParameters>) => Promise<ObjectId<"TiffGenerationContext">>;
+    addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarize: Binarize) => Promise<unknown>;
+    completeTiff: (tiffOperation: ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
+    createMRZRecognizer: (configuration: DeepPartial<MrzRecognizerConfig>) => Promise<ObjectId<"MrzRecognizerContext">>;
+    recognizeMRZ: <ImageType_2 extends Image>(mrzRecognizerToken: ObjectId<"MrzRecognizerContext">, image: ImageType_2) => Promise<MrzRecognitionResult & {
+        originalImage: ImageType_2;
+    }>;
+    releaseObject: <T>(objectToken: ObjectId<T>) => Promise<void>;
+    createOcrEngine: () => Promise<ObjectId<"TLDROcrContext">>;
+    performOcr: (tldrOcrToken: ObjectId<"TLDROcrContext">, image: Image) => Promise<Page>;
+    createGenericTextLineScanner: (configuration: DeepPartial<GtsConfig>) => Promise<ObjectId<"GenericTextLineScanner">>;
+    recognizeTextLine: <ImageType_3 extends Image>(scannerToken: ObjectId<"GenericTextLineScanner">, image: ImageType_3) => Promise<GtsResult & {
+        originalImage: ImageType_3;
+    }>;
+    cleanTextLineRecognitionQueue: (scannerToken: ObjectId<"GenericTextLineScanner">) => Promise<void>;
+    createDocumentQualityAnalyzer: (options: DeepPartial<DqaConfig>) => Promise<ObjectId<"DocumentQualityAnalyzer">>;
+    documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<DqaAnalysisResult>;
+    imageApplyFilter: (image: Image, filter: DeepPartial<ParametricFilter>) => Promise<RawImage>;
+    imageCrop: (image: Image, polygon: [Point, Point, Point, Point]) => Promise<RawImage>;
+    imageResize: (image: Image, destinationSize: number) => Promise<RawImage>;
+    imageRotate: (image: Image, rotations: ImageRotation) => Promise<RawImage>;
+    genericDocumentRecognizerCreate: (parameters: DeepPartial<GenericDocumentRecognizerParameters>) => Promise<ObjectId<"GenericDocumentRecognizer">>;
+    genericDocumentRecognizerRecognize: <ImageType_4 extends Image>(gdrToken: ObjectId<"GenericDocumentRecognizer">, image: ImageType_4, parameters: DeepPartial<GdrRecognitionParameters>) => Promise<GdrRecognitionResult & {
+        originalImage: ImageType_4;
+    }>;
+    version: () => Promise<string>;
+    __hasModuleFunction: (functionName: string) => Promise<any>;
+    __callModuleFunction: (functionName: string, args?: any[]) => Promise<any>;
+};
+export interface CroppedDetectionResult extends DetectionResult {
+    croppedImage: RawImage | null;
+    originalImage: Image;
+}
+export {};

package/@types/core-types.d.ts

@@ -0,0 +1,25 @@
+export * as BarcodeConfigs from './core/bridge/compiled/BarcodeConfigs';
+export * as BarcodeScannerTypes from './core/bridge/compiled/BarcodeScannerTypes';
+export * as BarcodeTypes from './core/bridge/compiled/BarcodeTypes';
+export * as CheckRecognizerTypes from './core/bridge/compiled/CheckRecognizerTypes';
+export * as CommonFieldType from './core/bridge/compiled/CommonFieldType';
+export * as DocumentDetectorTypes from './core/bridge/compiled/DocumentDetectorTypes';
+export * as DocumentQualityAnalyzerTypes from './core/bridge/compiled/DocumentQualityAnalyzerTypes';
+export * as EhicTypes from './core/bridge/compiled/EhicTypes';
+export * as GenericDocument from './core/bridge/compiled/GenericDocument';
+export * as GenericDocumentRecognizerConfigs from './core/bridge/compiled/GenericDocumentRecognizerConfigs';
+export * as GenericDocumentRecognizerTypes from './core/bridge/compiled/GenericDocumentRecognizerTypes';
+export * as GenericDocumentTypes from './core/bridge/compiled/GenericDocumentTypes';
+export * as GenericTextLineScannerTypes from './core/bridge/compiled/GenericTextLineScannerTypes';
+export * as Geometry from './core/bridge/compiled/Geometry';
+export * as ImageProcessorTypes from './core/bridge/compiled/ImageProcessorTypes';
+export * as LicensePlateScannerTypes from './core/bridge/compiled/LicensePlateScannerTypes';
+export * as MedicalCertificateTypes from './core/bridge/compiled/MedicalCertificateTypes';
+export * as MRZTypes from './core/bridge/compiled/MRZTypes';
+export * as OcrElements from './core/bridge/compiled/OcrElements';
+export * as ParametricFilters from './core/bridge/compiled/ParametricFilters';
+export * as PdfConfig from './core/bridge/compiled/PdfConfig';
+export * as TiffTypes from './core/bridge/compiled/TiffTypes';
+export * as FrameUtilities from './core/bridge/compiled/FrameUtilities';
+export type { ObjectId, Image, CroppedDetectionResult } from './core/worker/ScanbotSDK.Core';
+export { PartiallyConstructible, type RawImage, type DeepPartial, type Point, type Rectangle } from './core/bridge/common';

package/@types/cropping-view.d.ts

@@ -8,7 +8,9 @@ import { Point } from "./utils/dto/Point";
 import { MagneticLine } from "./utils/dto/MagneticLine";
 import { Polygon } from "./utils/dto/Polygon";
 import MagnifierView, { MagnifierOptions } from "./view/cropping/magnifier-view";
+import { ImageProcessorTypes } from "./core-types";
 import { ICroppingViewHandle } from "./interfaces/i-cropping-view-handle";
+import { DocumentDetectorTypes } from "./core-types";
 export interface CroppingViewProps {
     configuration: CroppingViewConfiguration;
     container?: HTMLElement;
@@ -20,6 +22,7 @@ export interface CroppingViewProps {
 }
 export interface CroppingViewState {
     image: string;
+    documentDetectionResult: DocumentDetectorTypes.DetectionResult;
     polygon: Polygon;
     calculatedSize: Size;
     animation: {
@@ -67,7 +70,7 @@ export default class CroppingView extends React.Component<CroppingViewProps, Cro
      */
     apply(): Promise<CroppingResult>;
     MAX_ROTATIONS: number;
-    toCcwRotations(cw: number): number;
+    toCoreRotations(cw: number): ImageProcessorTypes.ImageRotation;
     rotate(rotations: number): Promise<void>;
     detect(): Promise<void>;
     dispose(): void;
@@ -80,5 +83,4 @@ export default class CroppingView extends React.Component<CroppingViewProps, Cro
     calculateScale(existingRotations: number, appliedRotations: number, calculatedSize: Size): number;
     calculateRatio(calculatedSize: Size): number;
     calculateMargin(size: Size): Point;
-    private detectContour;
 }

package/@types/document-scanner-view.d.ts

@@ -1,12 +1,12 @@
 import React from "react";
 import { DocumentScannerConfiguration } from "./model/configuration/document-scanner-configuration";
-import { DocumentDetectionResult } from "./model/document/document-detection-result";
 import { ScanbotCameraProps, ScanbotCameraState, ScannerView } from "./scanner-view";
 import { ShutterButton, ShutterButtonAction } from "./view/shutter-button";
 import { DocumentOutline } from "./view/document-outline";
 import { PolygonMovementPredicate } from "./utils/predicate/polygon-movement-predicate";
 import { Polygon } from "./utils/dto/Polygon";
 import { IDocumentScannerHandle } from "./interfaces/i-document-scanner-handle";
+import { CroppedDetectionResult, ObjectId, DocumentDetectorTypes } from "./core-types";
 export declare class DocumentScannerState extends ScanbotCameraState {
     action: ShutterButtonAction;
 }
@@ -28,20 +28,22 @@ export default class DocumentScannerView extends ScannerView<DocumentScannerProp
      * Public API functions
      */
     static create(configuration: DocumentScannerConfiguration): Promise<DocumentScannerView>;
-    detectAndCrop(): Promise<DocumentDetectionResult>;
+    detectAndCrop(): Promise<CroppedDetectionResult>;
     enableAutoCapture(): void;
     disableAutoCapture(): void;
     updateAutoCapture(enabled: boolean): void;
     isAutoCaptureEnabled(): boolean;
-    recognizer: any;
+    recognizer: Promise<ObjectId<"DocumentDetector">>;
     /**
      * Internal functions
      */
     componentDidMount(): Promise<void>;
     componentWillUnmount(): Promise<void>;
     detect(): Promise<void>;
-    getStatusString(detectionResult: any): string;
-    detectInWebWorker(): Promise<any>;
+    getStatusString(detectionResult: DocumentDetectorTypes.DetectionResult): DocumentDetectorTypes.DetectionStatus;
+    detectInWebWorker(): Promise<DocumentDetectorTypes.DetectionResult & {
+        originalImage: ImageData;
+    }>;
     preventAutoCapture?: boolean;
     handleAutoCapture(statusOk: boolean, polygon?: Polygon): Promise<void>;
     updateButton(action: ShutterButtonAction): void;

package/@types/generic-document-recognizer-view.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import { ScanbotCameraProps, ScanbotCameraState, ScannerView } from "./scanner-view";
+import { IGenericDocumentRecognizerScannerHandle } from "./interfaces/i-generic-document-recognizer-scanner-handle";
+import { GenericDocumentRecognizerConfiguration } from "./model/configuration/generic-document-recognizer-configuration";
+import type ScanbotSDK from "./scanbot-sdk";
+declare class GenericDocumentRecognizerProps extends ScanbotCameraProps {
+    configuration: GenericDocumentRecognizerConfiguration;
+    sdk: ScanbotSDK;
+}
+export default class GenericDocumentRecognizerView extends ScannerView<GenericDocumentRecognizerProps, ScanbotCameraState> implements IGenericDocumentRecognizerScannerHandle {
+    private configuration;
+    private genericDocumentRecognizer;
+    private enabled;
+    private finder?;
+    constructor(props: GenericDocumentRecognizerProps);
+    static create(sdk: ScanbotSDK, configuration: GenericDocumentRecognizerConfiguration): Promise<IGenericDocumentRecognizerScannerHandle>;
+    componentDidMount(): void;
+    componentWillUnmount(): Promise<void>;
+    private detect;
+    render(): React.JSX.Element;
+}
+export {};

package/@types/index.d.ts

@@ -1,8 +1,5 @@
 export { IDocumentScannerHandle } from "./interfaces/i-document-scanner-handle";
 export { DocumentScannerConfiguration, StyleConfiguration, TextConfiguration, CaptureButtonStyleConfiguration, OutlineStyleConfiguration, HintTextConfiguration, OutlineLabelStyleConfiguration, CaptureAnimationStyleConfiguration, OutlinePolygonStyleConfiguration } from "./model/configuration/document-scanner-configuration";
-export { DocumentDetectionResult } from "./model/document/document-detection-result";
-export { ContourDetectionResult } from "./model/document/contour-detection-result";
-export * as DetectionStatus from "./model/document/detection-status";
 
 export { ViewFinderScannerConfiguration } from "./model/configuration/view-finder-scanner-configuration";
 
@@ -12,49 +9,80 @@ export { CroppingResult } from "./model/response/cropping-result";
 
 export { IBarcodeScannerHandle } from "./interfaces/i-barcode-scanner-handle";
 export { BarcodeScannerConfiguration } from "./model/configuration/barcode-scanner-configuration";
-export { BarcodeResult } from "./model/barcode/barcode-result";
-export { BarcodeFormat } from "./model/barcode/barcode-format";
-export { EngineMode } from "./model/barcode/engine-mode";
 export { BarcodeCountConfiguration, BarcodeCountStyleConfiguration } from "./model/configuration/barcode-count-configuration";
+export { BarcodeScannerResultWithSize } from "./model/barcode/barcode-result";
 
 export { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
 export { MrzScannerConfiguration, MrzScannerAccumulatedFrameVerificationConfiguration } from "./model/configuration/mrz-scanner-configuration";
-export { MrzResult, MrzCheckDigits, MrzField, MRZFieldValidationStatus } from "./model/mrz/mrz-result";
 export * as SimpleMrzRecognizer from "./service/simple-mrz-recognizer";
 
-export { TextDataScannerResult } from './model/generic-text-line-recognizer/text-data-scanner-result';
 export { TextDataScannerConfiguration, TextDetectionCallback } from "./model/configuration/text-data-scanner-configuration";
 export { ITextDataScannerHandle } from "./interfaces/i-text-data-scanner-handle";
 
 export { VINScannerConfiguration } from "./model/configuration/vin-scanner-configuration";
 
+export { GenericDocumentRecognizerConfiguration } from "./model/configuration/generic-document-recognizer-configuration";
+export { default as GenericDocumentRecognizer } from "./service/generic-document-recognizer";
+
+export { PdfGenerator } from "./service/pdf-generator";
+export { TiffGenerator } from "./service/tiff-generator";
+
 export { OcrData, default as OcrEngine, Rect } from "./service/ocr-engine";
-export { Point } from "./utils/dto/Point";
 export { MagneticLine } from "./utils/dto/MagneticLine";
 
-export { ImageProcessor, Rotation } from "./service/image-processor";
-export * as ParametricFilters from "./core/compiled/ParametricFilters";
-
-export { default as DocumentQualityAnalyzerConfiguration } from "./model/configuration/document-quality-analyzer-configuration";
 export { default as DocumentQualityAnalyzer } from "./service/document-quality-analyzer";
-export { default as DocumentQualityAnalyzerResult, DocumentQuality } from "./model/response/document-quality-analyzer-result";
 
-export { default as PublicUtils } from "./service/public-utils";
+export { PublicUtils } from "./service/public-utils";
 export { Size } from "./utils/dto/Size";
 export { VideoSize } from "./utils/dto/VideoSize";
 
 export { SelectionOverlayConfiguration, IBarcodePolygonHandle, IBarcodePolygonLabelHandle, BarcodePolygonStyle, SelectionOverlayTextFormat, SelectionOverlayStyleConfiguration, BarcodePolygonLabelStyle } from "./model/configuration/selection-overlay-configuration";
 
-export { default as PdfGenerator, PdfGenerationOptions, PageDirection, PageSize, PageFit } from "./service/pdf-generator";
-export { default as TiffGenerator, TiffGenerationOptions } from "./service/tiff-generator";
-
-export { BinarizationFilter, ColorFilter, ImageFilter } from "./model/filter-types";
 export { Polygon } from "./utils/dto/Polygon";
-export { Barcode } from "./model/barcode/barcode";
+
+//TODO We currently have two implementations of Point in: utils/dto/Point & core-types. Should this be refactored? 
+export { Point as Point2 } from "./utils/dto/Point";
 
 export { InitializationOptions } from "./model/configuration/initialization-options";
 export { LicenseInfo } from "./model/response/license-info";
 export { CameraInfo, CameraFacingMode } from "./model/camera-info";
 
+export { ConsumeType } from "./consume-type";
+
+export { BrowserCameras, CameraDetectionStrategy, DiscoverCameraMode } from './utils/browser-cameras';
+
 export { default as ScanbotSDKUI2 } from "./ui2/scanbot-sdk-ui";
-export * as UIConfig from "./ui2/configuration";
+export * as UIConfig from "./ui2/configuration";
+export {
+    BarcodeConfigs,
+    BarcodeScannerTypes,
+    BarcodeTypes,
+    CheckRecognizerTypes,
+    CommonFieldType,
+    DocumentDetectorTypes,
+    DocumentQualityAnalyzerTypes,
+    EhicTypes,
+    GenericDocument,
+    GenericDocumentRecognizerConfigs,
+    GenericDocumentRecognizerTypes,
+    GenericDocumentTypes,
+    GenericTextLineScannerTypes,
+    Geometry,
+    ImageProcessorTypes,
+    LicensePlateScannerTypes,
+    MedicalCertificateTypes,
+    MRZTypes,
+    OcrElements,
+    ParametricFilters,
+    PdfConfig,
+    TiffTypes,
+    FrameUtilities,
+    ObjectId, Image, CroppedDetectionResult,
+    PartiallyConstructible, RawImage, DeepPartial, Point, Rectangle
+} from "./core-types";
+
+// We also need to export the Config-namespace as a whole, because it is directly used in 
+// ScanbotSDK.ts and without it, the API docs would be incomplete.
+// In the API docs, Config and the types that are directly exported from ./core-types above are
+// automatically reconciled. 
+export * as Config from "./core-types"; 

package/@types/interfaces/i-document-scanner-handle.d.ts

@@ -1,7 +1,7 @@
-import { DocumentDetectionResult } from "../model/document/document-detection-result";
 import { IScannerCommon } from "./i-scanner-common-handle";
+import type { CroppedDetectionResult } from "../core-types";
 export interface IDocumentScannerHandle extends IScannerCommon {
-    detectAndCrop(): Promise<DocumentDetectionResult>;
+    detectAndCrop(): Promise<CroppedDetectionResult>;
     enableAutoCapture(): void;
     disableAutoCapture(): void;
     isAutoCaptureEnabled(): boolean;

package/@types/interfaces/i-generic-document-recognizer-scanner-handle.d.ts

@@ -0,0 +1,3 @@
+import { IScannerCommon } from "./i-scanner-common-handle";
+export interface IGenericDocumentRecognizerScannerHandle extends IScannerCommon {
+}

package/@types/model/barcode/barcode-result.d.ts

@@ -1,10 +1,18 @@
-import { ImageDataWrapper } from "../image-data-wrapper";
-import { Barcode } from "./barcode";
-export declare class BarcodeResult {
-    barcodes: Barcode[];
-    imageData: ImageData;
-    constructor(barcodes: Barcode[], imageData: ImageData);
-    /** @internal */
-    static fromWorker(inputs: any[], image: ImageDataWrapper): BarcodeResult;
+import { Size } from "../../utils/dto/Size";
+import type { BarcodeScannerTypes } from "../../core-types";
+export declare class BarcodeScannerResultWithSize {
+    coreResult: {
+        barcodes: BarcodeScannerTypes.BarcodeItem[];
+        originalImage?: ImageData;
+    };
+    barcodes: BarcodeScannerTypes.BarcodeItem[];
+    originalImageSize: Size | null;
+    /**
+     * @internal
+     */
+    constructor(coreResult: {
+        barcodes: BarcodeScannerTypes.BarcodeItem[];
+        originalImage?: ImageData;
+    });
     isEmpty(): boolean;
 }

package/@types/model/barcode/barcode.d.ts

@@ -1,14 +1,4 @@
-import { Point } from "../../utils/dto/Point";
-import { BarcodeFormat } from "./barcode-format";
-export declare class Barcode {
-    format: BarcodeFormat;
-    text: string;
-    parsedText: any;
-    rawBytes: Uint8Array;
-    points: Point[];
-    barcodeImage: Uint8Array;
-    constructor(format: BarcodeFormat, text: string, parsedText: string, bytes: Uint8Array, points: Point[], barcodeImage: Uint8Array);
-    id(): string;
-    equals(barcode: Barcode): unknown;
-    static fromWorker(input: any): Barcode;
-}
+import { BarcodeScannerTypes } from "../../core-types";
+export declare function barcodesEqual(barcodeItem1: BarcodeScannerTypes.BarcodeItem, barcodeItem2: BarcodeScannerTypes.BarcodeItem): boolean;
+export declare function barcodeId(barcode: BarcodeScannerTypes.BarcodeItem): string;
+export declare function barcodeItemFromText(text: string): BarcodeScannerTypes.BarcodeItem;

package/@types/model/camera-info.d.ts

@@ -2,6 +2,7 @@ export type CameraFacingMode = 'front' | 'back' | 'unknown';
 export interface CameraInfo {
     deviceId: string;
     label: string;
-    facingMode?: CameraFacingMode;
-    supportsTorchControl?: boolean;
+    maxNumPixels: number | undefined;
+    supportsTorchControl: boolean | undefined;
+    facingMode: CameraFacingMode;
 }

package/@types/model/configuration/barcode-scanner-configuration.d.ts

@@ -1,9 +1,8 @@
-import { BarcodeResult } from "../barcode/barcode-result";
-import { EngineMode } from "../barcode/engine-mode";
-import { BarcodeFormat } from "../barcode/barcode-format";
 import { SelectionOverlayConfiguration } from "./selection-overlay-configuration";
 import { BarcodeCountConfiguration } from "./barcode-count-configuration";
 import { ViewFinderScannerConfiguration } from "./view-finder-scanner-configuration";
+import { BarcodeScannerTypes, type DeepPartial } from "../../core-types";
+import type { BarcodeScannerResultWithSize } from "../barcode/barcode-result";
 export declare class BarcodeScannerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
     /**
@@ -11,9 +10,7 @@ export declare class BarcodeScannerConfiguration extends ViewFinderScannerConfig
      */
     captureDelay?: number;
     overlay?: SelectionOverlayConfiguration;
-    engineMode?: EngineMode;
-    barcodeFormats?: BarcodeFormat[];
-    returnBarcodeImage?: boolean;
+    detectionParameters?: Omit<DeepPartial<BarcodeScannerTypes.BarcodeRecognizerParameters>, "live">;
     /**
      * Special property to enable barcode count mode.
      * This is a type of a ready-to-use user interface scanning and counting found barcodes.
@@ -29,7 +26,17 @@ export declare class BarcodeScannerConfiguration extends ViewFinderScannerConfig
     zoom?: number;
     /**
      */
-    onBarcodesDetected?: (e: BarcodeResult) => void;
-    _onDetectionFailed?: (e: ImageData) => void;
+    onBarcodesDetected?: (e: BarcodeScannerResultWithSize) => void;
+    /**
+     * Note that the ImageData is only available at the point in time when _onDetectionFailed is invoked.
+     * The underlying buffer will be reused in the next detection cycle and will not be available anymore.
+     * @internal
+     * */
+    _onDetectionFailed?: (originalImageSize: ImageData) => void;
+    /**
+     * If set, limit the resolution of the image that is used for barcode recognition.
+     * A lower value will result in faster processing times but may reduce recognition quality.
+     */
+    desiredRecognitionResolution?: number;
     static fromJson(json: any): BarcodeScannerConfiguration;
 }

package/@types/model/configuration/cropping-view-configuration.d.ts

@@ -1,5 +1,6 @@
 import { Polygon } from "../../utils/dto/Polygon";
 import { BaseConfiguration } from "./base-configuration";
+import type { Image } from "../../core-types";
 export declare class CroppingViewMagneticLineStyle {
     disabled?: boolean;
     color?: string;
@@ -42,8 +43,13 @@ export declare class CroppingViewConfiguration extends BaseConfiguration {
      * Enhances drag-to-crop experience. True by default
      */
     disableScroll?: boolean;
+    /**
+     * The polygon that defines the initial cropping area.
+     * All points should have relative coordinates between 0 and 1.
+     * If this is not set, the cropping area is initialized with an automatically detected outline of the document.
+     */
     polygon?: Polygon;
-    image: Uint8Array;
+    image: Image;
     /**
      * Initial rotations of the original image. Default is 0
      */

package/@types/model/configuration/document-scanner-configuration.d.ts

@@ -1,18 +1,12 @@
 import { ScannerConfiguration } from "./scanner-configuration";
+import { DocumentDetectorTypes, DeepPartial, CroppedDetectionResult } from "../../core-types";
 export declare class TextConfiguration {
     constructor(hint?: HintTextConfiguration);
     hint?: HintTextConfiguration;
 }
-export interface HintTextConfiguration {
-    OK?: string;
-    OK_SmallSize?: string;
-    OK_BadAngles?: string;
-    OK_BadAspectRatio?: string;
-    OK_OffCenter?: string;
-    Error_NothingDetected?: string;
-    Error_Brightness?: string;
-    Error_Noise?: string;
-}
+export type HintTextConfiguration = {
+    [key in DocumentDetectorTypes.DetectionStatus]: string;
+};
 export declare class StyleConfiguration {
     constructor();
     outline?: OutlineStyleConfiguration;
@@ -53,16 +47,7 @@ export declare class CaptureButtonStyleConfiguration {
 }
 export declare class DocumentScannerConfiguration extends ScannerConfiguration {
     constructor();
-    /**
-     * The minimum score in percent (0 - 100) of the perspective
-     * distortion to accept a detected document. Default is 75.0.
-     */
-    acceptedAngleScore?: number;
-    /**
-     * The minimum document width or height in percent (0-100)
-     * of the screen size to accept a detected document. Default is 80.0.
-     */
-    acceptedSizeScore?: number;
+    detectionParameters?: DeepPartial<DocumentDetectorTypes.DetectionParameters>;
     /**
      * If auto-capture is enabled and when a document is detected, it will be automatically
      * captured when conditions are good and the auto-snapping time-out elapses.
@@ -107,13 +92,7 @@ export declare class DocumentScannerConfiguration extends ScannerConfiguration {
     /**
      * Document detected callback. Continuous callback,
      * stopped only when detection is stopped or camera widget is disposed.
-     * Result contains the following properties:
-     * detectionStatus: "OK",
-     * success: true,
-     * cropped: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD...",
-     * original: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD...",
-     * polygon: Array(4)}
      */
-    onDocumentDetected?: (e: any) => void;
+    onDocumentDetected?: (result: CroppedDetectionResult) => void;
     static fromJson(json: any): DocumentScannerConfiguration;
 }

package/@types/model/configuration/generic-document-recognizer-configuration.d.ts

@@ -0,0 +1,9 @@
+import type { DeepPartial, GenericDocumentRecognizerTypes } from "../../core-types";
+import { ViewFinderScannerConfiguration } from "./view-finder-scanner-configuration";
+export declare class GenericDocumentRecognizerConfiguration extends ViewFinderScannerConfiguration {
+    constructor();
+    detectorParameters?: DeepPartial<GenericDocumentRecognizerTypes.GenericDocumentRecognizerParameters>;
+    /** Callback is called for every analyzed frame. */
+    onDocumentDetected?: (result: GenericDocumentRecognizerTypes.RecognitionResult) => void;
+    static fromJson(json: DeepPartial<GenericDocumentRecognizerConfiguration>): GenericDocumentRecognizerConfiguration;
+}

package/@types/model/configuration/initialization-options.d.ts

@@ -1,10 +1,12 @@
+import { CameraDetectionStrategy } from "../../utils/browser-cameras";
 export interface InitializationOptions {
     /**
      * Scanbot Web SDK License key. Required
      */
     licenseKey: string;
     /**
-     * Location of the Core WebAssembly Engine. Optional. Defaults to '/'
+     * Location of the Core WebAssembly Engine. Mandatory.
+     * @deprecated This option is deprecated and will be replaced by the option `enginePath` in the next major release.
      */
     engine?: string;
     /**
@@ -28,4 +30,11 @@ export interface InitializationOptions {
      * Defaults to '?CURRENT_SDK_VERSION'.
      */
     requestSuffix?: string;
+    /**
+     * On devices with multiple cameras, it is difficult to choose which camera to use for scanning.
+     * You can choose from several different automatic detection strategies described by
+     * {@link CameraDetectionStrategy}.
+     * Defaults to `FAST_DEFERRED`.
+     */
+    bestCameraDetectionStrategy?: CameraDetectionStrategy;
 }

package/@types/model/configuration/mrz-scanner-configuration.d.ts

@@ -1,4 +1,4 @@
-import { MrzResult } from "../mrz/mrz-result";
+import { DeepPartial, MRZTypes } from "../../core-types";
 import { ViewFinderScannerConfiguration } from "./view-finder-scanner-configuration";
 export interface MrzScannerAccumulatedFrameVerificationConfiguration {
     /** Maximum number of accumulated frames to inspect to verify a scan result */
@@ -9,8 +9,9 @@ export interface MrzScannerAccumulatedFrameVerificationConfiguration {
 }
 export declare class MrzScannerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
-    accumulatedFrameVerificationConfiguration?: MrzScannerAccumulatedFrameVerificationConfiguration;
-    onMrzDetected?: (e: MrzResult) => void;
+    /** {@displayType `DeepPartial<MRZTypes.RecognizerConfiguration>`} {@link Config.MRZTypes.RecognizerConfiguration}*/
+    recognizerConfiguration?: DeepPartial<MRZTypes.RecognizerConfiguration>;
+    onMrzDetected?: (e: MRZTypes.RecognitionResult) => void;
     _onDetectionFailed?: (e: ImageData) => void;
     static fromJson(json: any): MrzScannerConfiguration;
 }

package/@types/model/configuration/scanner-configuration.d.ts

@@ -8,6 +8,7 @@ export declare class ScannerConfiguration extends BaseConfiguration {
         width: number;
         height: number;
     };
+    static DEFAULT_ACCEPTED_BRIGHTNESS_SCORE: number;
     static DEFAULT_ACCEPTED_ANGLE_SCORE: number;
     static DEFAULT_ACCEPTED_SIZE_SCORE: number;
     /**
@@ -15,6 +16,10 @@ export declare class ScannerConfiguration extends BaseConfiguration {
      */
     videoConstraints?: any;
     mirrored?: boolean;
+    /**
+     * Camera id or camera label.
+     * A list of available cameras can be obtained from {@link ScanbotSDK.cameras}.
+     **/
     preferredCamera?: string;
     spinnerColor?: string;
     backgroundColor?: string;
@@ -26,6 +31,9 @@ export declare class ScannerConfiguration extends BaseConfiguration {
     static mapVideoConstraints(json: any, configuration: ScannerConfiguration): void;
     /**
      * Error callback of the SDK.
+     * If any error was reported, your scanner might not be scanning anymore, e.g. due to an out-of-memory error.
+     * You should dispose the scanner and use {@link ScanbotSDK.destroy} and {@link ScanbotSDK.initialize} to
+     * re-initialize the SDK.
      */
     onError?: (e: any) => void;
 }

package/@types/model/configuration/selection-overlay-configuration.d.ts

@@ -1,8 +1,8 @@
-import { Barcode } from "../barcode/barcode";
+import type { BarcodeScannerTypes } from "../../core-types";
 export type SelectionOverlayTextFormat = "Text" | "TextAndFormat" | "None";
 export declare class BarcodePolygonStyle {
-    fill?: string;
-    stroke?: string;
+    fillColor?: string;
+    strokeColor?: string;
     strokeWidth?: number;
     cornerRadius?: number;
 }
@@ -44,5 +44,5 @@ export declare class SelectionOverlayConfiguration {
      */
     automaticSelectionEnabled?: boolean;
     style?: SelectionOverlayStyleConfiguration;
-    onBarcodeFound?: (code: Barcode, polygon: IBarcodePolygonHandle, label: IBarcodePolygonLabelHandle) => void;
+    onBarcodeFound?: (code: BarcodeScannerTypes.BarcodeItem, polygon: IBarcodePolygonHandle, label: IBarcodePolygonLabelHandle) => void;
 }