scanbot-web-sdk 6.0.0-dev.2 → 6.0.0-dev.4

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

@@ -1,14 +1,14 @@
 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 { DocumentQualityAnalyzerConfiguration, type DocumentQualityAnalyzerResult } 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 { DocumentDetectorParameters, type DocumentDetectionResult } 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 { GenericDocumentRecognizerConfig, RecognitionParameters as GdrRecognitionParameters, type RecognitionResult as GdrRecognitionResult } from "../bridge/compiled/GenericDocumentRecognizerTypes";
-import { type Binarize, TIFFWriterParameters } from "../bridge/compiled/TiffTypes";
+import { type BarcodeDocumentFormat, BarcodeScannerConfiguration, type BarcodeScannerResult } from "../bridge/compiled/BarcodeScannerTypes";
+import { GenericDocumentRecognizerParameters, RecognitionParameters as GdrRecognitionParameters, type RecognitionResult as GdrRecognitionResult } from "../bridge/compiled/GenericDocumentRecognizerTypes";
+import { type Binarization, 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. */
@@ -36,39 +36,50 @@ 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>;
+    detectDocument: (image: Image, options: DeepPartial<DocumentDetectorParameters>) => Promise<DocumentDetectionResult>;
     detectAndCropDocument: (image: Image) => Promise<CroppedDetectionResult>;
-    createDocumentDetector: (options: DeepPartial<DetectionParameters>) => Promise<ObjectId<"DocumentDetector">>;
-    documentDetectorDetect: (documentDetectorToken: ObjectId<"DocumentDetector">, image: Image) => Promise<DetectionResult>;
+    createDocumentDetector: (options: DeepPartial<DocumentDetectorParameters>) => Promise<ObjectId<"DocumentDetector">>;
+    documentDetectorDetect: <ImageType extends Image>(documentDetectorToken: ObjectId<"DocumentDetector">, image: ImageType) => Promise<DocumentDetectionResult & {
+        originalImage: ImageType;
+    }>;
     parseBarcodeDocument: (options: BarcodeDocumentFormat[], data: string) => Promise<GenericDocument | null>;
-    createBarcodeRecognizer: (options: DeepPartial<BarcodeRecognizerParameters>) => Promise<ObjectId<"BarcodeRecognizer">>;
-    recognizeBarcodes: (barcodeRecognizerToken: ObjectId<"BarcodeRecognizer">, image: Image) => Promise<BarcodeScannerResult>;
+    createBarcodeRecognizer: (options: DeepPartial<BarcodeScannerConfiguration>) => 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>;
+    addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarization: Binarization) => Promise<unknown>;
     completeTiff: (tiffOperation: ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
     createMRZRecognizer: (configuration: DeepPartial<MrzRecognizerConfig>) => Promise<ObjectId<"MrzRecognizerContext">>;
-    recognizeMRZ: (mrzRecognizerToken: ObjectId<"MrzRecognizerContext">, image: Image) => Promise<MrzRecognitionResult>;
+    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: (scannerToken: ObjectId<"GenericTextLineScanner">, image: Image) => Promise<GtsResult>;
+    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>;
+    createDocumentQualityAnalyzer: (options: DeepPartial<DocumentQualityAnalyzerConfiguration>) => Promise<ObjectId<"DocumentQualityAnalyzer">>;
+    documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<DocumentQualityAnalyzerResult>;
     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: (config: DeepPartial<GenericDocumentRecognizerConfig>) => Promise<ObjectId<"GenericDocumentRecognizer">>;
-    genericDocumentRecognizerRecognize: (gdrToken: ObjectId<"GenericDocumentRecognizer">, image: Image, parameters: DeepPartial<GdrRecognitionParameters>) => Promise<GdrRecognitionResult>;
+    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 {
+export interface CroppedDetectionResult extends DocumentDetectionResult {
     croppedImage: RawImage | null;
     originalImage: Image;
 }

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

@@ -7,7 +7,9 @@ export * as DocumentDetectorTypes from './core/bridge/compiled/DocumentDetectorT
 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';
@@ -19,5 +21,6 @@ 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 * as FrameAccumulationTypes from './core/bridge/compiled/FrameAccumulationTypes';
 export type { ObjectId, Image, CroppedDetectionResult } from './core/worker/ScanbotSDK.Core';
-export type { PartiallyConstructible, RawImage, DeepPartial, Point, Rectangle } from './core/bridge/common';
+export { PartiallyConstructible, type RawImage, type DeepPartial, type Point, type Rectangle } from './core/bridge/common';

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

@@ -22,7 +22,7 @@ export interface CroppingViewProps {
 }
 export interface CroppingViewState {
     image: string;
-    documentDetectionResult: DocumentDetectorTypes.DetectionResult;
+    documentDetectionResult: DocumentDetectorTypes.DocumentDetectionResult;
     polygon: Polygon;
     calculatedSize: Size;
     animation: {

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

@@ -40,8 +40,10 @@ export default class DocumentScannerView extends ScannerView<DocumentScannerProp
     componentDidMount(): Promise<void>;
     componentWillUnmount(): Promise<void>;
     detect(): Promise<void>;
-    getStatusString(detectionResult: DocumentDetectorTypes.DetectionResult): DocumentDetectorTypes.DetectionStatus;
-    detectInWebWorker(): Promise<DocumentDetectorTypes.DetectionResult>;
+    getStatusString(detectionResult: DocumentDetectorTypes.DocumentDetectionResult): DocumentDetectorTypes.DocumentDetectionStatus;
+    detectInWebWorker(): Promise<DocumentDetectorTypes.DocumentDetectionResult & {
+        originalImage: ImageData;
+    }>;
     preventAutoCapture?: boolean;
     handleAutoCapture(statusOk: boolean, polygon?: Polygon): Promise<void>;
     updateButton(action: ShutterButtonAction): void;

package/@types/index.d.ts

@@ -28,26 +28,62 @@ 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 { default as DocumentQualityAnalyzer } from "./service/document-quality-analyzer";
 
-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 { BinarizationFilter, ColorFilter } from "./model/filter-types";
 export { Polygon } from "./utils/dto/Polygon";
 
+//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 Config from "./core-types";
+export {
+    BarcodeConfigs,
+    BarcodeScannerTypes,
+    BarcodeTypes,
+    CheckRecognizerTypes,
+    CommonFieldType,
+    DocumentDetectorTypes,
+    DocumentQualityAnalyzerTypes,
+    EhicTypes,
+    GenericDocument,
+    GenericDocumentRecognizerConfigs,
+    GenericDocumentRecognizerTypes,
+    GenericDocumentTypes,
+    GenericTextLineScannerTypes,
+    Geometry,
+    ImageProcessorTypes,
+    LicensePlateScannerTypes,
+    MedicalCertificateTypes,
+    MRZTypes,
+    OcrElements,
+    ParametricFilters,
+    PdfConfig,
+    TiffTypes,
+    FrameUtilities,
+    FrameAccumulationTypes,
+    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/model/barcode/barcode-result.d.ts

@@ -1,8 +1,18 @@
 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;
-    constructor(barcodes: BarcodeScannerTypes.BarcodeItem[], originalImageSize: Size);
+    originalImageSize: Size | null;
+    /**
+     * @internal
+     */
+    constructor(coreResult: {
+        barcodes: BarcodeScannerTypes.BarcodeItem[];
+        originalImage?: ImageData;
+    });
     isEmpty(): boolean;
 }

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

@@ -1,3 +1,4 @@
-import type { BarcodeScannerTypes } from "../../core-types";
+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

@@ -2,7 +2,6 @@ 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 { Size } from "../../utils/dto/Size";
 import type { BarcodeScannerResultWithSize } from "../barcode/barcode-result";
 export declare class BarcodeScannerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
@@ -11,7 +10,7 @@ export declare class BarcodeScannerConfiguration extends ViewFinderScannerConfig
      */
     captureDelay?: number;
     overlay?: SelectionOverlayConfiguration;
-    detectionParameters?: Omit<DeepPartial<BarcodeScannerTypes.BarcodeRecognizerParameters>, "live">;
+    detectionParameters?: Omit<DeepPartial<BarcodeScannerTypes.BarcodeScannerConfiguration>, "live">;
     /**
      * Special property to enable barcode count mode.
      * This is a type of a ready-to-use user interface scanning and counting found barcodes.
@@ -28,8 +27,12 @@ export declare class BarcodeScannerConfiguration extends ViewFinderScannerConfig
     /**
      */
     onBarcodesDetected?: (e: BarcodeScannerResultWithSize) => void;
-    /** @internal */
-    _onDetectionFailed?: (originalImageSize: Size) => 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.

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

@@ -43,6 +43,11 @@ 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: Image;
     /**

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

@@ -1,11 +1,11 @@
 import { ScannerConfiguration } from "./scanner-configuration";
-import { DocumentDetectorTypes, DeepPartial } from "../../core-types";
+import { DocumentDetectorTypes, DeepPartial, CroppedDetectionResult } from "../../core-types";
 export declare class TextConfiguration {
     constructor(hint?: HintTextConfiguration);
     hint?: HintTextConfiguration;
 }
 export type HintTextConfiguration = {
-    [key in DocumentDetectorTypes.DetectionStatus]: string;
+    [key in DocumentDetectorTypes.DocumentDetectionStatus]: string;
 };
 export declare class StyleConfiguration {
     constructor();
@@ -47,7 +47,7 @@ export declare class CaptureButtonStyleConfiguration {
 }
 export declare class DocumentScannerConfiguration extends ScannerConfiguration {
     constructor();
-    detectionParameters?: DeepPartial<DocumentDetectorTypes.DetectionParameters>;
+    detectionParameters?: DeepPartial<DocumentDetectorTypes.DocumentDetectorParameters>;
     /**
      * 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.
@@ -92,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

@@ -2,7 +2,7 @@ import type { DeepPartial, GenericDocumentRecognizerTypes } from "../../core-typ
 import { ViewFinderScannerConfiguration } from "./view-finder-scanner-configuration";
 export declare class GenericDocumentRecognizerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
-    detectorParameters?: DeepPartial<GenericDocumentRecognizerTypes.GenericDocumentRecognizerConfig>;
+    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,3 +1,4 @@
+import { CameraDetectionStrategy } from "../../utils/browser-cameras";
 export interface InitializationOptions {
     /**
      * Scanbot Web SDK License key. Required
@@ -29,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

@@ -10,7 +10,7 @@ export interface MrzScannerAccumulatedFrameVerificationConfiguration {
 export declare class MrzScannerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
     /** {@displayType `DeepPartial<MRZTypes.RecognizerConfiguration>`} {@link Config.MRZTypes.RecognizerConfiguration}*/
-    recognizerConfiguration: DeepPartial<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

@@ -16,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;
@@ -27,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 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;
 }

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

@@ -1,6 +1,6 @@
 import { ScannerConfiguration } from "./scanner-configuration";
 import { ViewFinderConfiguration, UserGuidanceConfiguration } from "../../ui2/configuration";
-import { DeepPartial } from "../../ui2/configuration/utils";
+import { DeepPartial } from "../../ui2/common";
 export declare class ViewFinderScannerConfiguration extends ScannerConfiguration {
     constructor(resolution: {
         width: number;

package/@types/model/error/media-error.d.ts

@@ -24,4 +24,5 @@ export declare class MediaError extends Error {
     static tryCheckPermission(): Promise<void>;
     static hasDeniedPermission(): boolean;
     static hasCheckedPermission(): boolean;
+    static createFromDOMException(err: DOMException | unknown): MediaError;
 }