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

package/@types/scanbot-sdk.d.ts

@@ -11,7 +11,6 @@ import { PdfGenerator } from './service/pdf-generator';
 import { TiffGenerator } from './service/tiff-generator';
 import { PublicUtils } from "./service/public-utils";
 import { Polygon } from "./utils/dto/Polygon";
-import { BarcodeScannerResultWithSize } from "./model/barcode/barcode-result";
 import { MrzScannerConfiguration } from "./model/configuration/mrz-scanner-configuration";
 import { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
 import SimpleMrzRecognizer from "./service/simple-mrz-recognizer";
@@ -21,11 +20,13 @@ import { VINScannerConfiguration } from "./model/configuration/vin-scanner-confi
 import { ITextDataScannerHandle } from "./interfaces/i-text-data-scanner-handle";
 import DocumentQualityAnalyzer from "./service/document-quality-analyzer";
 import ScanbotSDKUI from "./ui2/scanbot-sdk-ui";
-import { Image, DeepPartial, RawImage, ObjectId } from "./core-types";
+import { Image, DeepPartial, RawImage, ObjectId, Point, GenericTextLineScannerTypes, GenericDocumentRecognizerTypes, TiffTypes, PdfConfig, ParametricFilters, ImageProcessorTypes, DocumentQualityAnalyzerTypes, MRZTypes, BarcodeScannerTypes, CroppedDetectionResult, DocumentDetectorTypes } from "./core-types";
 import * as Config from "./core-types";
 import GenericDocumentRecognizer from "./service/generic-document-recognizer";
 import { GenericDocumentRecognizerConfiguration } from "./model/configuration/generic-document-recognizer-configuration";
 import { ConsumeType } from "./consume-type";
+import { Stats } from "./utils/stats";
+import { BrowserCameras } from "./utils/browser-cameras";
 export default class ScanbotSDK {
     /** @internal */
     bridge: WorkerBridge;
@@ -50,18 +51,23 @@ export default class ScanbotSDK {
      * Image Operations
      */
     toDataUrl(imageBuffer: ArrayBuffer): Promise<string>;
-    /** @param detectionParameters {@displayType `DeepPartial<Config.DocumentDetectorTypes.DetectionParameters>`} {@link Config.DocumentDetectorTypes.DetectionParameters}*/
-    detectDocument(imageBuffer: Image, detectionParameters?: DeepPartial<Config.DocumentDetectorTypes.DetectionParameters>, consumeImage?: ConsumeType): Promise<Config.DocumentDetectorTypes.DetectionResult>;
-    detectAndCropDocument(imageBuffer: Image, consumeImage?: ConsumeType): Promise<Config.CroppedDetectionResult>;
-    /** @param detectionParameters {@displayType `Omit<DeepPartial<Config.BarcodeScannerTypes.BarcodeRecognizerParameters>, "live">`} {@link Config.BarcodeScannerTypes.BarcodeRecognizerParameters}*/
-    detectBarcodes(base64: string, detectionParameters: Omit<DeepPartial<Config.BarcodeScannerTypes.BarcodeRecognizerParameters>, "live">): Promise<BarcodeScannerResultWithSize>;
-    parseBarcodeDocument(acceptedDocumentFormats: Config.BarcodeScannerTypes.BarcodeDocumentFormat[], rawBarcodeData: string): Promise<Config.GenericDocument.GenericDocument>;
+    /** @param detectionParameters {@displayType `DeepPartial<DocumentDetectorTypes.DetectionParameters>`} {@link DocumentDetectorTypes.DetectionParameters}*/
+    detectDocument(imageBuffer: Image, detectionParameters?: DeepPartial<DocumentDetectorTypes.DetectionParameters>, consumeImage?: ConsumeType): Promise<DocumentDetectorTypes.DetectionResult>;
+    detectAndCropDocument(imageBuffer: Image, consumeImage?: ConsumeType): Promise<CroppedDetectionResult>;
+    /**
+     * @param image An image URL (e.g. Data URL or HTTP URL) or an Image object
+     * @param detectionParameters {@displayType `Omit<DeepPartial<BarcodeScannerTypes.BarcodeRecognizerParameters>, "live">`} {@link BarcodeScannerTypes.BarcodeRecognizerParameters}
+     * */
+    detectBarcodes(image: string | Image, partialDetectionParameters?: DeepPartial<Omit<BarcodeScannerTypes.BarcodeRecognizerParameters, "live">>, consumeImage?: ConsumeType): Promise<BarcodeScannerTypes.BarcodeScannerResult & {
+        originalImage: Image;
+    }>;
+    parseBarcodeDocument(acceptedDocumentFormats: BarcodeScannerTypes.BarcodeDocumentFormat[], rawBarcodeData: string): Promise<Config.GenericDocument.GenericDocument>;
     createSimpleMRZRecognizer(): Promise<SimpleMrzRecognizer>;
     createOcrEngine(): Promise<OcrEngine>;
-    /** @param config {@displayType `DeepPartial<Config.DocumentQualityAnalyzerTypes.Config>`} {@link Config.DocumentQualityAnalyzerTypes.Config}*/
-    createDocumentQualityAnalyzer(config?: DeepPartial<Config.DocumentQualityAnalyzerTypes.Config>): Promise<DocumentQualityAnalyzer>;
-    imageRotate(image: Image, rotation: Config.ImageProcessorTypes.ImageRotation, consumeImage?: ConsumeType): Promise<RawImage>;
-    imageFilter(image: Image, filter: Config.ParametricFilters.ParametricFilter, consumeImage?: ConsumeType): Promise<RawImage>;
+    /** @param config {@displayType `DeepPartial<DocumentQualityAnalyzerTypes.Config>`} {@link DocumentQualityAnalyzerTypes.Config}*/
+    createDocumentQualityAnalyzer(config?: DeepPartial<DocumentQualityAnalyzerTypes.Config>): Promise<DocumentQualityAnalyzer>;
+    imageRotate(image: Image, rotation: ImageProcessorTypes.ImageRotation, consumeImage?: ConsumeType): Promise<RawImage>;
+    imageFilter(image: Image, filter: ParametricFilters.ParametricFilter, consumeImage?: ConsumeType): Promise<RawImage>;
     /** Crops and stretches the image to the convex hull of the supplied points. All points should have relative coordinates between 0 and 1. */
     imageCrop(image: Image, polygon: Polygon, consumeImage?: ConsumeType): Promise<RawImage>;
     imageResize(image: Image, destinationSize: number, consumeImage?: ConsumeType): Promise<RawImage>;
@@ -69,12 +75,12 @@ export default class ScanbotSDK {
      * Misc. Features
      */
     getLicenseInfo(): Promise<LicenseInfo>;
-    /** @param options {@displayType `DeepPartial<Config.PdfConfig.PdfConfig>`} {@link Config.PdfConfig.PdfConfig}*/
-    beginPdf(options: DeepPartial<Config.PdfConfig.PdfConfig>): Promise<PdfGenerator>;
-    /** @param options {@displayType `DeepPartial<Config.TiffTypes.TIFFWriterParameters>`} {@link Config.TiffTypes.TIFFWriterParameters} */
-    beginTiff(options?: DeepPartial<Config.TiffTypes.TIFFWriterParameters>): Promise<TiffGenerator>;
-    /** @param options {@displayType `DeepPartial<Config.GenericDocumentRecognizerTypes.GenericDocumentRecognizerConfig>`} {@link Config.GenericDocumentRecognizerTypes.GenericDocumentRecognizerConfig}*/
-    createGenericDocumentRecognizer(options: DeepPartial<Config.GenericDocumentRecognizerTypes.GenericDocumentRecognizerConfig>): Promise<GenericDocumentRecognizer>;
+    /** @param options {@displayType `DeepPartial<PdfConfig.PdfConfig>`} {@link PdfConfig.PdfConfig}*/
+    beginPdf(options: DeepPartial<PdfConfig.PdfConfig>): Promise<PdfGenerator>;
+    /** @param options {@displayType `DeepPartial<TiffTypes.TIFFWriterParameters>`} {@link TiffTypes.TIFFWriterParameters} */
+    beginTiff(options?: DeepPartial<TiffTypes.TIFFWriterParameters>): Promise<TiffGenerator>;
+    /** @param options {@displayType `DeepPartial<GenericDocumentRecognizerTypes.GenericDocumentRecognizerParameters>`} {@link GenericDocumentRecognizerTypes.GenericDocumentRecognizerParameters}*/
+    createGenericDocumentRecognizer(options: DeepPartial<GenericDocumentRecognizerTypes.GenericDocumentRecognizerParameters>): Promise<GenericDocumentRecognizer>;
     imageToJpeg(image: Image, consumeImage?: ConsumeType): Promise<Uint8Array>;
     get version(): string;
     private _utils;
@@ -94,30 +100,255 @@ export default class ScanbotSDK {
             acceptedAngleScore?: number;
             acceptedSizeScore?: number;
             acceptedBrightnessThreshold?: number;
-            requiredAspectRatios?: Config.Geometry.AspectRatio[];
+            requiredAspectRatios?: {
+                readonly width?: number;
+                readonly height?: number;
+                _marker?: () => void;
+            }[];
             rectangleOfInterest?: Config.Rectangle;
             _marker?: () => void;
-        }) => Promise<Config.DocumentDetectorTypes.DetectionResult>;
-        detectAndCropDocument: (image: Image) => Promise<Config.CroppedDetectionResult>;
+        }) => Promise<DocumentDetectorTypes.DetectionResult>;
+        detectAndCropDocument: (image: Image) => Promise<CroppedDetectionResult>;
         createDocumentDetector: (options: {
             acceptedAngleScore?: number;
             acceptedSizeScore?: number;
             acceptedBrightnessThreshold?: number;
-            requiredAspectRatios?: Config.Geometry.AspectRatio[];
+            requiredAspectRatios?: {
+                readonly width?: number;
+                readonly height?: number;
+                _marker?: () => void;
+            }[];
             rectangleOfInterest?: Config.Rectangle;
             _marker?: () => void;
         }) => Promise<ObjectId<"DocumentDetector">>;
-        documentDetectorDetect: (documentDetectorToken: ObjectId<"DocumentDetector">, image: Image) => Promise<Config.DocumentDetectorTypes.DetectionResult>;
-        parseBarcodeDocument: (options: Config.BarcodeScannerTypes.BarcodeDocumentFormat[], data: string) => Promise<Config.GenericDocument.GenericDocument>;
+        documentDetectorDetect: <ImageType extends Image>(documentDetectorToken: ObjectId<"DocumentDetector">, image: ImageType) => Promise<DocumentDetectorTypes.DetectionResult & {
+            originalImage: ImageType;
+        }>;
+        parseBarcodeDocument: (options: BarcodeScannerTypes.BarcodeDocumentFormat[], data: string) => Promise<Config.GenericDocument.GenericDocument>;
         createBarcodeRecognizer: (options: {
-            configurators?: Config.BarcodeConfigs.BarcodeConfig[];
-            engineMode?: Config.BarcodeScannerTypes.EngineMode;
+            configurators?: ({
+                readonly _type?: "CodabarConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly returnStartEnd?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "Code11Config";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly stripCheckDigits?: boolean;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly checksum?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "Code39Config";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly stripCheckDigits?: boolean;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly code32?: boolean;
+                readonly code39?: boolean;
+                readonly pzn?: boolean;
+                readonly tryCode39ExtendedMode?: boolean;
+                readonly useCode39CheckDigit?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "Code93Config";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "Code128Config";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "Code2Of5Config";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly stripCheckDigits?: boolean;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly iata2of5?: boolean;
+                readonly code25?: boolean;
+                readonly industrial2of5?: boolean;
+                readonly useIATA2OF5Checksum?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "DataBarConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "DataBarExpandedConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "DataBarLimitedConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "ITFConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "MSIPlesseyConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly stripCheckDigits?: boolean;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly checksumAlgorithms?: Config.BarcodeConfigs.MSIPlesseyChecksumAlgorithm[];
+                _marker?: () => void;
+            } | {
+                readonly _type?: "UpcEanConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly stripCheckDigits?: boolean;
+                readonly ean8?: boolean;
+                readonly ean13?: boolean;
+                readonly upca?: boolean;
+                readonly upce?: boolean;
+                readonly extensions?: Config.BarcodeTypes.UpcEanExtensionBehavior;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "PharmaCodeConfig";
+                readonly minimum1DQuietZoneSize?: number;
+                readonly regexFilter?: string;
+                readonly minimumValue?: number;
+                readonly allowNarrowBarsOnly?: boolean;
+                readonly allowWideBarsOnly?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "AztecConfig";
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "QRCodeConfig";
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                readonly qr?: boolean;
+                readonly microQr?: boolean;
+                readonly rmqr?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "PDF417Config";
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "MicroPDF417Config";
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "DataMatrixConfig";
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "MaxiCodeConfig";
+                readonly regexFilter?: string;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "AustraliaPostConfig";
+                readonly regexFilter?: string;
+                readonly australiaPostCustomerFormat?: Config.BarcodeConfigs.AustraliaPostCustomerFormat;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "JapanPostConfig";
+                readonly regexFilter?: string;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "RoyalMailConfig";
+                readonly regexFilter?: string;
+                readonly stripCheckDigits?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "RoyalTNTPostConfig";
+                readonly regexFilter?: string;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "USPSIntelligentMailConfig";
+                readonly regexFilter?: string;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "PharmaCodeTwoTrackConfig";
+                readonly regexFilter?: string;
+                readonly minimumValue?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GS1CompositeConfig";
+                readonly regexFilter?: string;
+                readonly minimum1DQuietZoneSize?: number;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GroupOneDConfig";
+                readonly regexFilter?: string;
+                readonly minimum1DQuietZoneSize?: number;
+                readonly stripCheckDigits?: boolean;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                readonly formats?: Config.BarcodeTypes.BarcodeFormat[];
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GroupTwoDConfig";
+                readonly regexFilter?: string;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                readonly formats?: Config.BarcodeTypes.BarcodeFormat[];
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GroupFourStateConfig";
+                readonly regexFilter?: string;
+                readonly formats?: Config.BarcodeTypes.BarcodeFormat[];
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GroupCommonConfig";
+                readonly regexFilter?: string;
+                readonly minimum1DQuietZoneSize?: number;
+                readonly stripCheckDigits?: boolean;
+                readonly minimumTextLength?: number;
+                readonly maximumTextLength?: number;
+                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                readonly strictMode?: boolean;
+                readonly formats?: Config.BarcodeTypes.BarcodeFormat[];
+                _marker?: () => void;
+            })[];
+            engineMode?: BarcodeScannerTypes.EngineMode;
             live?: boolean;
-            acceptedDocumentFormats?: Config.BarcodeScannerTypes.BarcodeDocumentFormat[];
+            acceptedDocumentFormats?: BarcodeScannerTypes.BarcodeDocumentFormat[];
             returnBarcodeImage?: boolean;
             _marker?: () => void;
         }) => Promise<ObjectId<"BarcodeRecognizer">>;
-        recognizeBarcodes: (barcodeRecognizerToken: ObjectId<"BarcodeRecognizer">, image: Image) => Promise<Config.BarcodeScannerTypes.BarcodeScannerResult>;
+        recognizeBarcodes: <ImageType_1 extends Image>(barcodeRecognizerToken: ObjectId<"BarcodeRecognizer">, image: ImageType_1) => Promise<BarcodeScannerTypes.BarcodeScannerResult & {
+            originalImage: ImageType_1;
+        }>;
         beginPdf: (options: {
             readonly attributes?: {
                 readonly author?: string;
@@ -127,32 +358,49 @@ export default class ScanbotSDK {
                 readonly keywords?: string;
                 _marker?: () => void;
             };
-            readonly pageSize?: Config.PdfConfig.PageSize;
-            readonly pageDirection?: Config.PdfConfig.PageDirection;
-            readonly pageFit?: Config.PdfConfig.PageFit;
+            readonly pageSize?: PdfConfig.PageSize;
+            readonly pageDirection?: PdfConfig.PageDirection;
+            readonly pageFit?: PdfConfig.PageFit;
             readonly dpi?: number;
             readonly jpegQuality?: number;
-            readonly resamplingMethod?: Config.PdfConfig.ResamplingMethod;
+            readonly resamplingMethod?: PdfConfig.ResamplingMethod;
             _marker?: () => void;
         }) => Promise<ObjectId<"PdfGenerationContext">>;
         addPageToPdf: (pdfOperation: ObjectId<"PdfGenerationContext">, image: Image) => Promise<void>;
         completePdf: (pdfOperation: ObjectId<"PdfGenerationContext">) => Promise<Uint8Array>;
         beginTiff: (options: {
-            compression?: Config.TiffTypes.CompressionMode;
+            compression?: TiffTypes.CompressionMode;
             jpegQuality?: number;
             zipCompressionLevel?: number;
             dpi?: number;
-            userFields?: Config.TiffTypes.UserField[];
+            userFields?: {
+                readonly tag?: number;
+                readonly name?: string;
+                readonly value?: {
+                    readonly _type?: "UserFieldDoubleValue";
+                    readonly value?: number;
+                    _marker?: () => void;
+                } | {
+                    readonly _type?: "UserFieldStringValue";
+                    readonly value?: string;
+                    _marker?: () => void;
+                } | {
+                    readonly _type?: "UserFieldIntValue";
+                    readonly value?: number;
+                    _marker?: () => void;
+                };
+                _marker?: () => void;
+            }[];
             binarizationFilter?: {
                 readonly _type?: "ScanbotBinarizationFilter";
-                outputMode?: Config.ParametricFilters.OutputMode;
+                outputMode?: ParametricFilters.OutputMode;
                 _marker?: () => void;
             } | {
                 readonly _type?: "CustomBinarizationFilter";
-                outputMode?: Config.ParametricFilters.OutputMode;
+                outputMode?: ParametricFilters.OutputMode;
                 denoise?: number;
                 radius?: number;
-                preset?: Config.ParametricFilters.BinarizationFilterPreset;
+                preset?: ParametricFilters.BinarizationFilterPreset;
                 _marker?: () => void;
             } | {
                 readonly _type?: "ColorDocumentFilter";
@@ -183,7 +431,7 @@ export default class ScanbotSDK {
             };
             _marker?: () => void;
         }) => Promise<ObjectId<"TiffGenerationContext">>;
-        addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarize: Config.TiffTypes.Binarize) => Promise<unknown>;
+        addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarize: TiffTypes.Binarize) => Promise<unknown>;
         completeTiff: (tiffOperation: ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
         createMRZRecognizer: (configuration: {
             accumulatedResultsVerifierConfig?: {
@@ -193,7 +441,9 @@ export default class ScanbotSDK {
             };
             _marker?: () => void;
         }) => Promise<ObjectId<"MrzRecognizerContext">>;
-        recognizeMRZ: (mrzRecognizerToken: ObjectId<"MrzRecognizerContext">, image: Image) => Promise<Config.MRZTypes.RecognitionResult>;
+        recognizeMRZ: <ImageType_2 extends Image>(mrzRecognizerToken: ObjectId<"MrzRecognizerContext">, image: ImageType_2) => Promise<MRZTypes.RecognitionResult & {
+            originalImage: ImageType_2;
+        }>;
         releaseObject: <T>(objectToken: ObjectId<T>) => Promise<void>;
         createOcrEngine: () => Promise<ObjectId<"TLDROcrContext">>;
         performOcr: (tldrOcrToken: ObjectId<"TLDROcrContext">, image: Image) => Promise<Config.OcrElements.Page>;
@@ -218,11 +468,17 @@ export default class ScanbotSDK {
             };
             _marker?: () => void;
         }) => Promise<ObjectId<"GenericTextLineScanner">>;
-        recognizeTextLine: (scannerToken: ObjectId<"GenericTextLineScanner">, image: Image) => Promise<Config.GenericTextLineScannerTypes.ScannerResult>;
+        recognizeTextLine: <ImageType_3 extends Image>(scannerToken: ObjectId<"GenericTextLineScanner">, image: ImageType_3) => Promise<GenericTextLineScannerTypes.ScannerResult & {
+            originalImage: ImageType_3;
+        }>;
         cleanTextLineRecognitionQueue: (scannerToken: ObjectId<"GenericTextLineScanner">) => Promise<void>;
         createDocumentQualityAnalyzer: (options: {
-            readonly qualityThresholds?: Config.DocumentQualityAnalyzerTypes.QualityThreshold[];
-            readonly qualityIndices?: Config.DocumentQualityAnalyzerTypes.Quality[];
+            readonly qualityThresholds?: {
+                readonly symbolQuality?: number;
+                readonly symbolRatio?: number;
+                _marker?: () => void;
+            }[];
+            readonly qualityIndices?: DocumentQualityAnalyzerTypes.Quality[];
             readonly maxImageSize?: number;
             minEstimatedNumberOfSymbolsForDocument?: number;
             readonly minProcessedFraction?: number;
@@ -231,12 +487,12 @@ export default class ScanbotSDK {
             readonly tileSize?: number;
             _marker?: () => void;
         }) => Promise<ObjectId<"DocumentQualityAnalyzer">>;
-        documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<Config.DocumentQualityAnalyzerTypes.AnalysisResult>;
-        imageApplyFilter: (image: Image, filter: DeepPartial<Config.ParametricFilters.ParametricFilter>) => Promise<RawImage>;
-        imageCrop: (image: Image, polygon: [Config.Point, Config.Point, Config.Point, Config.Point]) => Promise<RawImage>;
+        documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<DocumentQualityAnalyzerTypes.AnalysisResult>;
+        imageApplyFilter: (image: Image, filter: DeepPartial<ParametricFilters.ParametricFilter>) => Promise<RawImage>;
+        imageCrop: (image: Image, polygon: [Point, Point, Point, Point]) => Promise<RawImage>;
         imageResize: (image: Image, destinationSize: number) => Promise<RawImage>;
-        imageRotate: (image: Image, rotations: Config.ImageProcessorTypes.ImageRotation) => Promise<RawImage>;
-        genericDocumentRecognizerCreate: (config: {
+        imageRotate: (image: Image, rotations: ImageProcessorTypes.ImageRotation) => Promise<RawImage>;
+        genericDocumentRecognizerCreate: (parameters: {
             resultAccumulationConfig?: {
                 minConfirmations?: number;
                 minConfidenceForStableField?: number;
@@ -244,18 +500,65 @@ export default class ScanbotSDK {
                 _marker?: () => void;
             };
             fieldExcludeList?: string[];
-            acceptedDocumentTypes?: string[];
+            configurations?: ({
+                readonly _type?: "DateValidationConfig";
+                readonly minBirthYear?: number;
+                readonly maxBirthYear?: number;
+                readonly minExpirationYear?: number;
+                readonly maxExpirationYear?: number;
+                readonly documentTypes?: Config.GenericDocumentTypes.DocumentType[];
+                _marker?: () => void;
+            } | {
+                readonly _type?: "EuropeanHealthInsuranceCardConfig";
+                readonly minBirthYear?: number;
+                readonly maxBirthYear?: number;
+                readonly minExpirationYear?: number;
+                readonly maxExpirationYear?: number;
+                readonly expectedCountry?: Config.GenericDocumentRecognizerConfigs.EHICIssuingCountry;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "MRZFallbackConfig";
+                readonly acceptedCountries?: string[];
+                readonly acceptedMRZTypes?: MRZTypes.DocumentType[];
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GDRGroupConfig";
+                readonly acceptedDocumentTypes?: Config.GenericDocumentTypes.DocumentType[];
+                _marker?: () => void;
+            })[];
             _marker?: () => void;
         }) => Promise<ObjectId<"GenericDocumentRecognizer">>;
-        genericDocumentRecognizerRecognize: (gdrToken: ObjectId<"GenericDocumentRecognizer">, image: Image, parameters: {
-            mode?: Config.GenericDocumentRecognizerTypes.RecognitionMode;
+        genericDocumentRecognizerRecognize: <ImageType_4 extends Image>(gdrToken: ObjectId<"GenericDocumentRecognizer">, image: ImageType_4, parameters: {
+            mode?: GenericDocumentRecognizerTypes.RecognitionMode;
             _marker?: () => void;
-        }) => Promise<Config.GenericDocumentRecognizerTypes.RecognitionResult>;
+        }) => Promise<GenericDocumentRecognizerTypes.RecognitionResult & {
+            originalImage: ImageType_4;
+        }>;
+        version: () => Promise<string>;
         __hasModuleFunction: (functionName: string) => Promise<any>;
         __callModuleFunction: (functionName: string, args?: any[]) => Promise<any>;
     };
     private licenseCheck;
-    /** @param partialConfig {@displayType `DeepPartial<Config.GenericTextLineScannerTypes.ScannerConfiguration>`} {@link Config.GenericTextLineScannerTypes.ScannerConfiguration}*/
+    /** @param partialConfig {@displayType `DeepPartial<GenericTextLineScannerTypes.ScannerConfiguration>`} {@link GenericTextLineScannerTypes.ScannerConfiguration}*/
     private createGenericTextLineScanner;
+    /**
+     * This method will destroy all web workers and free the memory held by the
+     * SDK (after the next run of the garbage collector).
+     *
+     * This function should not be called while a scanner is open or an API call is pending.
+     * If you do call this function while a scanner is open, the scanner will stop detecting anything,
+     * but the video will keep running. If you call this function while an API call is pending, that
+     * pending API call might never finish.
+     *
+     * After calling this function, no further calls to this object are allowed. To further use the SDK,
+     * it needs to be initialized again.
+     */
+    destroy(): void;
+    static cameras: BrowserCameras;
     static Config: typeof Config;
+    /**
+     * Used for testing purposes only.
+     * @internal
+     */
+    static _stats: Stats;
 }

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

@@ -6,6 +6,8 @@ export default class GenericDocumentRecognizer {
     private _recognizer;
     /** @internal */
     constructor(_sdk: ScanbotSDK, _recognizer: ObjectId<"GenericDocumentRecognizer">);
-    recognize(image: Image, parameters: DeepPartial<GenericDocumentRecognizerTypes.RecognitionParameters>, consumeImage?: ConsumeType): Promise<GenericDocumentRecognizerTypes.RecognitionResult>;
+    recognize<ImageType extends Image>(image: ImageType, parameters: DeepPartial<GenericDocumentRecognizerTypes.RecognitionParameters>, consumeImage?: ConsumeType): Promise<GenericDocumentRecognizerTypes.RecognitionResult & {
+        originalImage: ImageType;
+    }>;
     release(): Promise<void>;
 }

package/@types/service/simple-mrz-recognizer.d.ts

@@ -5,7 +5,9 @@ export default class SimpleMrzRecognizer {
     private _sdk;
     private _mrzRecognizerToken;
     constructor(_sdk: ScanbotSDK, _mrzRecognizerToken: Promise<ObjectId<"MrzRecognizerContext">>);
-    recognize(image: Image, consumeImage?: ConsumeType): Promise<MRZTypes.RecognitionResult | undefined>;
+    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<MRZTypes.RecognitionResult & {
+        originalImage: ImageType;
+    }>;
     recognizeURL(imageURL: string): Promise<MRZTypes.RecognitionResult | undefined>;
     release(): Promise<void>;
 }

package/@types/service/text-data-recognizer.d.ts

@@ -5,7 +5,9 @@ export default class TextDataScanner {
     private _sdk;
     private _textDataScannerToken;
     constructor(_sdk: ScanbotSDK, _textDataScannerToken: Promise<ObjectId<"GenericTextLineScanner">>);
-    recognize(image: Image, consumeImage?: ConsumeType): Promise<GenericTextLineScannerTypes.ScannerResult>;
+    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<GenericTextLineScannerTypes.ScannerResult & {
+        originalImage: ImageType;
+    }>;
     cleanRecognitionQueue(): Promise<void>;
     recognizeURL(imageURL: string): Promise<GenericTextLineScannerTypes.ScannerResult>;
     release(): Promise<void>;

package/@types/ui2/common.d.ts

@@ -0,0 +1,8 @@
+export type { Point, RawImage } from '../core-types';
+import { Point, Rectangle, Image } from '../core-types';
+type TypesThatAreOpaqueToDeepPartial = Function | Image | Point | Rectangle;
+export type DeepPartial<T> = T extends TypesThatAreOpaqueToDeepPartial ? T : T extends Array<infer I> ? DeepPartial<I>[] : T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare abstract class PartiallyConstructible {
+}

package/@types/ui2/configuration/ActionBarConfiguration.d.ts

@@ -1,41 +1,41 @@
-import { DeepPartial, PartiallyConstructible } from "./utils";
+import { DeepPartial, PartiallyConstructible } from "../common";
 import { RoundButton } from "./Common";
 /**
- Configuration of the buttons available in the action bar.
- */
+Configuration of the buttons available in the action bar.
+*/
 export declare class ActionBarConfiguration extends PartiallyConstructible {
     /**
-     Appearance of the flash button.
-     @defaultValue new RoundButton({
-        "visible": true,
-        "backgroundColor": "?sbColorSurfaceHigh",
-        "foregroundColor": "?sbColorOnPrimary",
-        "activeBackgroundColor": "?sbColorWarning",
-        "activeForegroundColor": "#1C1B1F"
-    });
-     */
+      Appearance of the flash button.
+      @defaultValue new RoundButton({
+          "visible": true,
+          "backgroundColor": "?sbColorSurfaceHigh",
+          "foregroundColor": "?sbColorOnPrimary",
+          "activeBackgroundColor": "?sbColorWarning",
+          "activeForegroundColor": "#1C1B1F"
+      });
+      */
     flashButton: RoundButton;
     /**
-     Appearance of the zoom button.
-     @defaultValue new RoundButton({
-        "visible": true,
-        "backgroundColor": "?sbColorSurfaceHigh",
-        "foregroundColor": "?sbColorOnPrimary",
-        "activeBackgroundColor": "?sbColorSurfaceHigh",
-        "activeForegroundColor": "?sbColorOnPrimary"
-    });
-     */
+      Appearance of the zoom button.
+      @defaultValue new RoundButton({
+          "visible": true,
+          "backgroundColor": "?sbColorSurfaceHigh",
+          "foregroundColor": "?sbColorOnPrimary",
+          "activeBackgroundColor": "?sbColorSurfaceHigh",
+          "activeForegroundColor": "?sbColorOnPrimary"
+      });
+      */
     zoomButton: RoundButton;
     /**
-     Appearance of the flip camera button.
-     @defaultValue new RoundButton({
-        "visible": true,
-        "backgroundColor": "?sbColorSurfaceHigh",
-        "foregroundColor": "?sbColorOnPrimary",
-        "activeBackgroundColor": "?sbColorSurfaceHigh",
-        "activeForegroundColor": "?sbColorOnPrimary"
-    });
-     */
+      Appearance of the flip camera button.
+      @defaultValue new RoundButton({
+          "visible": true,
+          "backgroundColor": "?sbColorSurfaceHigh",
+          "foregroundColor": "?sbColorOnPrimary",
+          "activeBackgroundColor": "?sbColorSurfaceHigh",
+          "activeForegroundColor": "?sbColorOnPrimary"
+      });
+      */
     flipCameraButton: RoundButton;
     /** @param source {@displayType `DeepPartial<ActionBarConfiguration>`} */
     constructor(source?: DeepPartial<ActionBarConfiguration>);