scanbot-web-sdk 6.0.0-dev.6 → 7.0.0-dev.2

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

@@ -15,18 +15,19 @@ import { MrzScannerConfiguration } from "./model/configuration/mrz-scanner-confi
 import { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
 import SimpleMrzRecognizer from "./service/simple-mrz-recognizer";
 import OcrEngine from "./service/ocr-engine";
-import { TextDataScannerConfiguration } from "./model/configuration/text-data-scanner-configuration";
+import { TextPatternScannerConfiguration } from "./model/configuration/text-pattern-scanner-configuration";
 import { VINScannerConfiguration } from "./model/configuration/vin-scanner-configuration";
-import { ITextDataScannerHandle } from "./interfaces/i-text-data-scanner-handle";
+import { ITextPatternScannerHandle } from "./interfaces/i-text-pattern-scanner-handle";
 import DocumentQualityAnalyzer from "./service/document-quality-analyzer";
 import ScanbotSDKUI from "./ui2/scanbot-sdk-ui";
-import { Image, DeepPartial, RawImage, ObjectId, Point, GenericTextLineScannerTypes, GenericDocumentRecognizerTypes, TiffTypes, PdfConfig, ParametricFilters, ImageTypes, DocumentQualityAnalyzerTypes, MRZTypes, BarcodeScannerTypes, BarcodeDocumentTypes, CroppedDetectionResult, DocumentDetectorTypes } from "./core-types";
+import { Image, DeepPartial, RawImage, ObjectId, Point, TextPatternScannerTypes, VinScannerTypes, TiffTypes, PdfConfigurationTypes, ParametricFilters, ImageTypes, DocumentQualityAnalyzerTypes, MrzTypes, BarcodeScannerTypes, BarcodeDocumentTypes, CroppedDetectionResult, DocumentScannerTypes, DocumentDataExtractorTypes } 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 { DocumentDataExtractor } from "./service/document-data-extractor";
+import { DocumentDataExtractorConfiguration } from "./model/configuration/document-data-extractor-configuration";
 import { ConsumeType } from "./consume-type";
 import { Stats } from "./utils/stats";
 import { BrowserCameras } from "./utils/browser-cameras";
+import { SBStorage } from "./service/storage/sb-storage";
 export default class ScanbotSDK {
     /** @internal */
     bridge: WorkerBridge;
@@ -37,6 +38,7 @@ export default class ScanbotSDK {
     private static _ui2;
     static get UI(): typeof ScanbotSDKUI;
     static initialize(options: InitializationOptions): Promise<ScanbotSDK>;
+    storage: SBStorage;
     /**
      * View Components
      */
@@ -44,19 +46,19 @@ export default class ScanbotSDK {
     createMrzScanner(configuration: MrzScannerConfiguration): Promise<IMrzScannerHandle>;
     createBarcodeScanner(configuration: BarcodeScannerConfiguration): Promise<IBarcodeScannerHandle>;
     openCroppingView(configuration: CroppingViewConfiguration): Promise<ICroppingViewHandle>;
-    createTextDataScanner(configuration: TextDataScannerConfiguration): Promise<ITextDataScannerHandle>;
-    createVINScanner(configuration: VINScannerConfiguration): Promise<ITextDataScannerHandle>;
-    createGenericDocumentRecognizerScanner(config: GenericDocumentRecognizerConfiguration): Promise<any>;
+    createTextPatternScanner(configuration: TextPatternScannerConfiguration): Promise<ITextPatternScannerHandle>;
+    createVINScanner(configuration: VINScannerConfiguration): Promise<ITextPatternScannerHandle>;
+    createDocumentDataExtractorScanner(config: DocumentDataExtractorConfiguration): Promise<any>;
     /**
      * Image Operations
      */
     toDataUrl(imageBuffer: ArrayBuffer): Promise<string>;
-    /** @param detectionParameters {@displayType `DeepPartial<DocumentDetectorTypes.DocumentDetectorParameters>`} {@link DocumentDetectorTypes.DocumentDetectorParameters}*/
-    detectDocument(imageBuffer: Image, detectionParameters?: DeepPartial<DocumentDetectorTypes.DocumentDetectorParameters>, consumeImage?: ConsumeType): Promise<DocumentDetectorTypes.DocumentDetectionResult>;
+    /** @param detectionParameters {@displayType `DeepPartial<DocumentScannerTypes.DocumentScannerParameters>`} {@link DocumentScannerTypes.DocumentScannerParameters}*/
+    detectDocument(image: Image, detectionParameters?: DeepPartial<DocumentScannerTypes.DocumentScannerParameters>, consumeImage?: ConsumeType): Promise<DocumentScannerTypes.DocumentDetectionResult>;
     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}
+     * @param detectionParameters {@displayType `Omit<DeepPartial<BarcodeScannerTypes.BarcodeScannerConfiguration>, "live">`} {@link BarcodeScannerTypes.BarcodeScannerConfiguration}
      * */
     detectBarcodes(image: string | Image, partialDetectionParameters?: DeepPartial<Omit<BarcodeScannerTypes.BarcodeScannerConfiguration, "live">>, consumeImage?: ConsumeType): Promise<BarcodeScannerTypes.BarcodeScannerResult & {
         originalImage: Image;
@@ -75,12 +77,12 @@ export default class ScanbotSDK {
      * Misc. Features
      */
     getLicenseInfo(): Promise<LicenseInfo>;
-    /** @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>;
+    /** @param options {@displayType `DeepPartial<PdfConfigurationTypes.PdfConfiguration>`} {@link PdfConfigurationTypes.PdfConfiguration}*/
+    beginPdf(options: DeepPartial<PdfConfigurationTypes.PdfConfiguration>): Promise<PdfGenerator>;
+    /** @param options {@displayType `DeepPartial<TiffTypes.TiffWriterParameters>`} {@link TiffTypes.TiffWriterParameters} */
+    beginTiff(options?: DeepPartial<TiffTypes.TiffWriterParameters>): Promise<TiffGenerator>;
+    /** @param options {@displayType `DeepPartial<DocumentDataExtractorTypes.DocumentDataExtractorConfiguration>`} {@link DocumentDataExtractorTypes.DocumentDataExtractorConfiguration}*/
+    createDocumentDataExtractor(options: DeepPartial<DocumentDataExtractorTypes.DocumentDataExtractorConfiguration>): Promise<DocumentDataExtractor>;
     imageToJpeg(image: Image, consumeImage?: ConsumeType): Promise<Uint8Array>;
     get version(): string;
     private _utils;
@@ -109,9 +111,9 @@ export default class ScanbotSDK {
             }[];
             ignoreOrientationMismatch?: boolean;
             _marker?: () => void;
-        }) => Promise<DocumentDetectorTypes.DocumentDetectionResult>;
+        }) => Promise<DocumentScannerTypes.DocumentDetectionResult>;
         detectAndCropDocument: (image: Image) => Promise<CroppedDetectionResult>;
-        createDocumentDetector: (options: {
+        createDocumentScanner: (options: {
             isLive?: boolean;
             acceptedAngleScore?: number;
             acceptedSizeScore?: number;
@@ -124,256 +126,313 @@ export default class ScanbotSDK {
             }[];
             ignoreOrientationMismatch?: boolean;
             _marker?: () => void;
-        }) => Promise<ObjectId<"DocumentDetector">>;
-        documentDetectorDetect: <ImageType extends Image>(documentDetectorToken: ObjectId<"DocumentDetector">, image: ImageType) => Promise<DocumentDetectorTypes.DocumentDetectionResult & {
+        }) => Promise<ObjectId<"DocumentScanner">>;
+        documentScannerDetect: <ImageType extends Image>(documentScannerToken: ObjectId<"DocumentScanner">, image: ImageType) => Promise<DocumentScannerTypes.DocumentDetectionResult & {
             originalImage: ImageType;
         }>;
         parseBarcodeDocument: (options: BarcodeDocumentTypes.BarcodeDocumentFormat[], data: string) => Promise<Config.GenericDocument.GenericDocument>;
-        createBarcodeRecognizer: (options: {
+        createBarcodeScanner: (options: {
             barcodeFormatConfigurations?: ({
                 readonly _type?: "BarcodeFormatCodabarConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
-                readonly returnStartEnd?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                returnStartEnd?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCode11Configuration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly stripCheckDigits?: boolean;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
-                readonly checksum?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                checksum?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCode39Configuration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly stripCheckDigits?: boolean;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
-                readonly code32?: boolean;
-                readonly code39?: boolean;
-                readonly pzn?: boolean;
-                readonly tryCode39ExtendedMode?: boolean;
-                readonly useCode39CheckDigit?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                code32?: boolean;
+                code39?: boolean;
+                pzn?: boolean;
+                tryCode39ExtendedMode?: boolean;
+                useCode39CheckDigit?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCode93Configuration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCode128Configuration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCode2Of5Configuration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly stripCheckDigits?: boolean;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
-                readonly iata2of5?: boolean;
-                readonly code25?: boolean;
-                readonly industrial2of5?: boolean;
-                readonly useIATA2OF5Checksum?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                iata2of5?: boolean;
+                code25?: boolean;
+                industrial2of5?: boolean;
+                useIATA2OF5Checksum?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatDataBarConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatDataBarExpandedConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatDataBarLimitedConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatITFConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatMSIPlesseyConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly stripCheckDigits?: boolean;
-                readonly minimumTextLength?: number;
-                readonly maximumTextLength?: number;
-                readonly checksumAlgorithms?: Config.BarcodeConfigs.MSIPlesseyChecksumAlgorithm[];
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                checksumAlgorithms?: Config.BarcodeConfigurationTypes.MsiPlesseyChecksumAlgorithm[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatUpcEanConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly stripCheckDigits?: boolean;
-                readonly ean8?: boolean;
-                readonly ean13?: boolean;
-                readonly upca?: boolean;
-                readonly upce?: boolean;
-                readonly extensions?: Config.BarcodeTypes.UpcEanExtensionBehavior;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                ean8?: boolean;
+                ean13?: boolean;
+                upca?: boolean;
+                upce?: boolean;
+                extensions?: Config.BarcodeTypes.UpcEanExtensionBehavior;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatPharmaCodeConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly minimumValue?: number;
-                readonly allowNarrowBarsOnly?: boolean;
-                readonly allowWideBarsOnly?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                minimumValue?: number;
+                allowNarrowBarsOnly?: boolean;
+                allowWideBarsOnly?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatAztecConfiguration";
-                readonly regexFilter?: string;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatQRCodeConfiguration";
-                readonly regexFilter?: string;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
-                readonly strictMode?: boolean;
-                readonly qr?: boolean;
-                readonly microQr?: boolean;
-                readonly rmqr?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
+                qr?: boolean;
+                microQr?: boolean;
+                rmqr?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatPDF417Configuration";
-                readonly regexFilter?: string;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
-                readonly strictMode?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatMicroPDF417Configuration";
-                readonly regexFilter?: string;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
-                readonly strictMode?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatDataMatrixConfiguration";
-                readonly regexFilter?: string;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatMaxiCodeConfiguration";
-                readonly regexFilter?: string;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatAustraliaPostConfiguration";
-                readonly regexFilter?: string;
-                readonly australiaPostCustomerFormat?: Config.BarcodeConfigs.AustraliaPostCustomerFormat;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                australiaPostCustomerFormat?: Config.BarcodeConfigurationTypes.AustraliaPostCustomerFormat;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatJapanPostConfiguration";
-                readonly regexFilter?: string;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatRoyalMailConfiguration";
-                readonly regexFilter?: string;
-                readonly stripCheckDigits?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                stripCheckDigits?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatRoyalTNTPostConfiguration";
-                readonly regexFilter?: string;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatUSPSIntelligentMailConfiguration";
-                readonly regexFilter?: string;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatPharmaCodeTwoTrackConfiguration";
-                readonly regexFilter?: string;
-                readonly minimumValue?: number;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimumValue?: number;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatGS1CompositeConfiguration";
-                readonly regexFilter?: string;
-                readonly minimum1DQuietZoneSize?: number;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
-                readonly strictMode?: boolean;
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonOneDConfiguration";
-                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[];
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
+                formats?: Config.BarcodeTypes.BarcodeFormat[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonTwoDConfiguration";
-                readonly regexFilter?: string;
-                readonly gs1Handling?: Config.BarcodeTypes.GS1Handling;
-                readonly strictMode?: boolean;
-                readonly formats?: Config.BarcodeTypes.BarcodeFormat[];
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
+                formats?: Config.BarcodeTypes.BarcodeFormat[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonFourStateConfiguration";
-                readonly regexFilter?: string;
-                readonly formats?: Config.BarcodeTypes.BarcodeFormat[];
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                formats?: Config.BarcodeTypes.BarcodeFormat[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonConfiguration";
-                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[];
+                regexFilter?: string;
+                minimumSizeScore?: number;
+                addAdditionalQuietZone?: boolean;
+                minimum1DQuietZoneSize?: number;
+                stripCheckDigits?: boolean;
+                minimumTextLength?: number;
+                maximumTextLength?: number;
+                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                strictMode?: boolean;
+                formats?: Config.BarcodeTypes.BarcodeFormat[];
                 _marker?: () => void;
             })[];
-            acceptedDocumentFormats?: BarcodeDocumentTypes.BarcodeDocumentFormat[];
+            extractedDocumentFormats?: BarcodeDocumentTypes.BarcodeDocumentFormat[];
             onlyAcceptDocuments?: boolean;
             returnBarcodeImage?: boolean;
             engineMode?: BarcodeScannerTypes.BarcodeScannerEngineMode;
             live?: boolean;
             _marker?: () => void;
-        }) => Promise<ObjectId<"BarcodeRecognizer">>;
-        recognizeBarcodes: <ImageType_1 extends Image>(barcodeRecognizerToken: ObjectId<"BarcodeRecognizer">, image: ImageType_1) => Promise<BarcodeScannerTypes.BarcodeScannerResult & {
+        }) => Promise<ObjectId<"BarcodeScanner">>;
+        scanBarcodes: <ImageType_1 extends Image>(barcodeScannerToken: ObjectId<"BarcodeScanner">, image: ImageType_1) => Promise<BarcodeScannerTypes.BarcodeScannerResult & {
             originalImage: ImageType_1;
         }>;
         beginPdf: (options: {
-            readonly attributes?: {
-                readonly author?: string;
-                readonly creator?: string;
-                readonly title?: string;
-                readonly subject?: string;
-                readonly keywords?: string;
+            attributes?: {
+                author?: string;
+                creator?: string;
+                title?: string;
+                subject?: string;
+                keywords?: string;
                 _marker?: () => void;
             };
-            readonly pageSize?: PdfConfig.PageSize;
-            readonly pageDirection?: PdfConfig.PageDirection;
-            readonly pageFit?: PdfConfig.PageFit;
-            readonly dpi?: number;
-            readonly jpegQuality?: number;
-            readonly resamplingMethod?: PdfConfig.ResamplingMethod;
+            pageSize?: PdfConfigurationTypes.PageSize;
+            pageDirection?: PdfConfigurationTypes.PageDirection;
+            pageFit?: PdfConfigurationTypes.PageFit;
+            dpi?: number;
+            jpegQuality?: number;
+            resamplingMethod?: PdfConfigurationTypes.ResamplingMethod;
             _marker?: () => void;
-        }) => Promise<ObjectId<"PdfGenerationContext">>; /**
-         * @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}
-         * */
+        }) => Promise<ObjectId<"PdfGenerationContext">>;
         addPageToPdf: (pdfOperation: ObjectId<"PdfGenerationContext">, image: Image) => Promise<void>;
         completePdf: (pdfOperation: ObjectId<"PdfGenerationContext">) => Promise<Uint8Array>;
         beginTiff: (options: {
@@ -382,19 +441,19 @@ export default class ScanbotSDK {
             zipCompressionLevel?: number;
             dpi?: number;
             userFields?: {
-                readonly tag?: number;
-                readonly name?: string;
-                readonly value?: {
+                tag?: number;
+                name?: string;
+                value?: {
                     readonly _type?: "UserFieldDoubleValue";
-                    readonly value?: number;
+                    value?: number;
                     _marker?: () => void;
                 } | {
                     readonly _type?: "UserFieldStringValue";
-                    readonly value?: string;
+                    value?: string;
                     _marker?: () => void;
                 } | {
                     readonly _type?: "UserFieldIntValue";
-                    readonly value?: number;
+                    value?: number;
                     _marker?: () => void;
                 };
                 _marker?: () => void;
@@ -441,21 +500,23 @@ export default class ScanbotSDK {
         }) => Promise<ObjectId<"TiffGenerationContext">>;
         addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarization: TiffTypes.Binarization) => Promise<unknown>;
         completeTiff: (tiffOperation: ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
-        createMRZRecognizer: (configuration: {
-            accumulatedResultsVerifierConfig?: {
+        createMRZScanner: (configuration: {
+            frameAccumulationConfiguration?: {
                 maximumNumberOfAccumulatedFrames?: number;
                 minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
                 _marker?: () => void;
             };
+            enableDetection?: boolean;
+            incompleteResultHandling?: MrzTypes.MrzIncompleteResultHandling;
             _marker?: () => void;
-        }) => Promise<ObjectId<"MrzRecognizerContext">>;
-        recognizeMRZ: <ImageType_2 extends Image>(mrzRecognizerToken: ObjectId<"MrzRecognizerContext">, image: ImageType_2) => Promise<MRZTypes.RecognitionResult & {
+        }) => Promise<ObjectId<"MRZScannerContext">>;
+        scanMRZ: <ImageType_2 extends Image>(mrzScannerToken: ObjectId<"MRZScannerContext">, image: ImageType_2) => Promise<MrzTypes.MrzScannerResult & {
             originalImage: ImageType_2;
         }>;
         releaseObject: <T>(objectToken: ObjectId<T>) => Promise<void>;
         createOcrEngine: () => Promise<ObjectId<"TLDROcrContext">>;
-        performOcr: (tldrOcrToken: ObjectId<"TLDROcrContext">, image: Image) => Promise<Config.OcrElements.Page>;
-        createGenericTextLineScanner: (configuration: {
+        performOcr: (tldrOcrToken: ObjectId<"TLDROcrContext">, image: Image) => Promise<Config.OcrTypes.Page>;
+        createTextPatternScanner: (configuration: {
             ocrResolutionLimit?: number;
             maximumNumberOfAccumulatedFrames?: number;
             minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
@@ -463,10 +524,6 @@ export default class ScanbotSDK {
                 readonly _type?: "DefaultContentValidator";
                 allowedCharacters?: string;
                 _marker?: () => void;
-            } | {
-                readonly _type?: "PresetContentValidator";
-                preset?: "VEHICLE_IDENTIFICATION_NUMBER";
-                _marker?: () => void;
             } | {
                 readonly _type?: "PatternContentValidator";
                 allowedCharacters?: string;
@@ -475,25 +532,36 @@ export default class ScanbotSDK {
                 _marker?: () => void;
             };
             _marker?: () => void;
-        }) => Promise<ObjectId<"GenericTextLineScanner">>;
-        recognizeTextLine: <ImageType_3 extends Image>(scannerToken: ObjectId<"GenericTextLineScanner">, image: ImageType_3) => Promise<GenericTextLineScannerTypes.ScannerResult & {
+        }) => Promise<ObjectId<"TextPatternScanner">>;
+        scanTextLine: <ImageType_3 extends Image>(scannerToken: ObjectId<"TextPatternScanner">, image: ImageType_3) => Promise<TextPatternScannerTypes.TextPatternScannerResult & {
             originalImage: ImageType_3;
         }>;
-        cleanTextLineRecognitionQueue: (scannerToken: ObjectId<"GenericTextLineScanner">) => Promise<void>;
+        cleanTextLineScanningQueue: (scannerToken: ObjectId<"TextPatternScanner">) => Promise<void>;
+        createVinScanner: (configuration: {
+            extractVINFromBarcode?: boolean;
+            ocrResolutionLimit?: number;
+            maximumNumberOfAccumulatedFrames?: number;
+            minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
+            _marker?: () => void;
+        }) => Promise<ObjectId<"VinScanner">>;
+        scanVin: <ImageType_4 extends Image>(scannerToken: ObjectId<"VinScanner">, image: ImageType_4) => Promise<VinScannerTypes.VinScannerResult & {
+            originalImage: ImageType_4;
+        }>;
+        cleanVinScanningQueue: (scannerToken: ObjectId<"VinScanner">) => Promise<void>;
         createDocumentQualityAnalyzer: (options: {
-            readonly qualityThresholds?: {
+            qualityThresholds?: {
                 readonly symbolQuality?: number;
                 readonly symbolRatio?: number;
                 _marker?: () => void;
             }[];
-            readonly qualityIndices?: DocumentQualityAnalyzerTypes.DocumentQuality[];
-            readonly detectOrientation?: boolean;
-            readonly maxImageSize?: number;
+            qualityIndices?: DocumentQualityAnalyzerTypes.DocumentQuality[];
+            detectOrientation?: boolean;
+            maxImageSize?: number;
             minEstimatedNumberOfSymbolsForDocument?: number;
-            readonly minProcessedFraction?: number;
-            readonly maxProcessedFraction?: number;
-            readonly earlyStopIfNSymbolsFound?: number;
-            readonly tileSize?: number;
+            minProcessedFraction?: number;
+            maxProcessedFraction?: number;
+            earlyStopIfNSymbolsFound?: number;
+            tileSize?: number;
             _marker?: () => void;
         }) => Promise<ObjectId<"DocumentQualityAnalyzer">>;
         documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<DocumentQualityAnalyzerTypes.DocumentQualityAnalyzerResult>;
@@ -501,7 +569,7 @@ export default class ScanbotSDK {
         imageCrop: (image: Image, polygon: [Point, Point, Point, Point]) => Promise<RawImage>;
         imageResize: (image: Image, destinationSize: number) => Promise<RawImage>;
         imageRotate: (image: Image, rotations: ImageTypes.ImageRotation) => Promise<RawImage>;
-        genericDocumentRecognizerCreate: (parameters: {
+        documentDataExtractorCreate: (parameters: {
             resultAccumulationConfig?: {
                 confirmationMethod?: Config.FrameAccumulationTypes.ConfirmationMethod;
                 minConfirmations?: number;
@@ -511,40 +579,38 @@ export default class ScanbotSDK {
             };
             fieldExcludeList?: string[];
             configurations?: ({
-                readonly _type?: "DateValidationConfig";
-                readonly minYear?: number;
-                readonly maxYear?: number;
-                readonly fieldTypeName?: string;
+                readonly _type?: "DateValidationConfiguration";
+                minYear?: number;
+                maxYear?: number;
+                fieldTypeName?: string;
                 _marker?: () => void;
             } | {
-                readonly _type?: "EuropeanHealthInsuranceCardConfig";
-                readonly expectedCountry?: Config.GenericDocumentRecognizerConfigs.EHICIssuingCountry;
+                readonly _type?: "EuropeanHealthInsuranceCardConfiguration";
+                expectedCountry?: Config.DocumentDataExtractorConfigurationTypes.EuropeanHealthInsuranceCardIssuingCountry;
                 _marker?: () => void;
             } | {
-                readonly _type?: "MRZFallbackConfig";
-                readonly acceptedCountries?: string[];
-                readonly acceptedMRZTypes?: MRZTypes.DocumentType[];
+                readonly _type?: "MRZFallbackConfiguration";
+                acceptedCountries?: string[];
+                acceptedMRZTypes?: MrzTypes.MrzDocumentType[];
                 _marker?: () => void;
             } | {
-                readonly _type?: "GDRGroupConfig";
-                readonly acceptedDocumentTypes?: string[];
+                readonly _type?: "DocumentDataExtractorCommonConfiguration";
+                acceptedDocumentTypes?: string[];
                 _marker?: () => void;
             })[];
             _marker?: () => void;
-        }) => Promise<ObjectId<"GenericDocumentRecognizer">>;
-        genericDocumentRecognizerRecognize: <ImageType_4 extends Image>(gdrToken: ObjectId<"GenericDocumentRecognizer">, image: ImageType_4, parameters: {
-            mode?: GenericDocumentRecognizerTypes.RecognitionMode;
+        }) => Promise<ObjectId<"DocumentDataExtractor">>;
+        documentDataExtractorExtract: <ImageType_5 extends Image>(gdrToken: ObjectId<"DocumentDataExtractor">, image: ImageType_5, parameters: {
+            mode?: DocumentDataExtractorTypes.DocumentDataExtractionMode;
             _marker?: () => void;
-        }) => Promise<GenericDocumentRecognizerTypes.RecognitionResult & {
-            originalImage: ImageType_4;
+        }) => Promise<DocumentDataExtractorTypes.DocumentDataExtractionResult & {
+            originalImage: ImageType_5;
         }>;
         version: () => Promise<string>;
         __hasModuleFunction: (functionName: string) => Promise<any>;
         __callModuleFunction: (functionName: string, args?: any[]) => Promise<any>;
     };
     private licenseCheck;
-    /** @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).