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

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

@@ -1,12 +1,9 @@
-import { TextDataScannerResult } from "../generic-text-line-recognizer/text-data-scanner-result";
 import { ViewFinderScannerConfiguration } from "./view-finder-scanner-configuration";
-export type ValidatorPreset = "VehicleIdentificationNumber";
-export type TextDetectionCallback = (e: TextDataScannerResult) => void;
+import { GenericTextLineScannerTypes, DeepPartial } from "../../core-types";
+export type TextDetectionCallback = (e: GenericTextLineScannerTypes.ScannerResult) => void;
 export declare class TextDataScannerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
-    ocrResolutionLimit?: number;
-    supportedLanguages?: string[];
-    validatorPreset?: ValidatorPreset;
+    ocrConfiguration?: DeepPartial<GenericTextLineScannerTypes.ScannerConfiguration>;
     onTextDetected?: TextDetectionCallback;
     static fromJson(json: any): TextDataScannerConfiguration;
 }

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

@@ -1,11 +1,12 @@
 import { ScannerConfiguration } from "./scanner-configuration";
 import { ViewFinderConfiguration, UserGuidanceConfiguration } from "../../ui2/configuration";
+import { DeepPartial } from "../../ui2/common";
 export declare class ViewFinderScannerConfiguration extends ScannerConfiguration {
     constructor(resolution: {
         width: number;
         height: number;
     });
-    finder?: ViewFinderConfiguration;
-    userGuidance?: UserGuidanceConfiguration;
+    finder?: DeepPartial<ViewFinderConfiguration>;
+    userGuidance?: DeepPartial<UserGuidanceConfiguration>;
     static mapFinderConfiguration(result: ViewFinderScannerConfiguration, json: any): void;
 }

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

@@ -1,8 +1,9 @@
 import { TextDetectionCallback } from "./text-data-scanner-configuration";
 import { ViewFinderScannerConfiguration } from "./view-finder-scanner-configuration";
+import { GenericTextLineScannerTypes, DeepPartial } from "../../core-types";
 export declare class VINScannerConfiguration extends ViewFinderScannerConfiguration {
     constructor();
-    ocrResolutionLimit?: number;
+    ocrConfiguration?: Omit<DeepPartial<GenericTextLineScannerTypes.ScannerConfiguration>, "validator">;
     onTextDetected?: TextDetectionCallback;
     static fromJson(json: any): VINScannerConfiguration;
 }

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;
 }

package/@types/model/response/cropping-result.d.ts

@@ -1,6 +1,7 @@
 import { Polygon } from "../../utils/dto/Polygon";
+import { RawImage } from "../../core-types";
 export declare class CroppingResult {
-    image: Uint8Array;
+    image: RawImage;
     polygon: Polygon;
     rotations: number;
 }

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

@@ -3,31 +3,30 @@ import { InitializationOptions } from "./model/configuration/initialization-opti
 import { DocumentScannerConfiguration } from "./model/configuration/document-scanner-configuration";
 import { BarcodeScannerConfiguration } from "./model/configuration/barcode-scanner-configuration";
 import { CroppingViewConfiguration } from "./model/configuration/cropping-view-configuration";
-import { ImageFilter } from './model/filter-types';
 import { LicenseInfo } from "./model/response/license-info";
 import { IDocumentScannerHandle } from "./interfaces/i-document-scanner-handle";
 import { IBarcodeScannerHandle } from "./interfaces/i-barcode-scanner-handle";
 import { ICroppingViewHandle } from "./interfaces/i-cropping-view-handle";
-import PdfGenerator, { PdfGenerationOptions } from './service/pdf-generator';
-import TiffGenerator, { TiffGenerationOptions } from './service/tiff-generator';
-import PublicUtils from "./service/public-utils";
+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 { BarcodeResult } from "./model/barcode/barcode-result";
-import { EngineMode } from "./model/barcode/engine-mode";
-import { BarcodeFormat } from "./model/barcode/barcode-format";
 import { MrzScannerConfiguration } from "./model/configuration/mrz-scanner-configuration";
 import { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
 import SimpleMrzRecognizer from "./service/simple-mrz-recognizer";
 import OcrEngine from "./service/ocr-engine";
-import { ContourDetectionResult } from "./model/document/contour-detection-result";
 import { TextDataScannerConfiguration } from "./model/configuration/text-data-scanner-configuration";
 import { VINScannerConfiguration } from "./model/configuration/vin-scanner-configuration";
 import { ITextDataScannerHandle } from "./interfaces/i-text-data-scanner-handle";
-import DocumentQualityAnalyzerConfiguration from "./model/configuration/document-quality-analyzer-configuration";
 import DocumentQualityAnalyzer from "./service/document-quality-analyzer";
-import { ImageProcessor } from "./service/image-processor";
-import * as imageFilters from "./core/compiled/ParametricFilters";
 import ScanbotSDKUI from "./ui2/scanbot-sdk-ui";
+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;
@@ -47,36 +46,519 @@ export default class ScanbotSDK {
     openCroppingView(configuration: CroppingViewConfiguration): Promise<ICroppingViewHandle>;
     createTextDataScanner(configuration: TextDataScannerConfiguration): Promise<ITextDataScannerHandle>;
     createVINScanner(configuration: VINScannerConfiguration): Promise<ITextDataScannerHandle>;
+    createGenericDocumentRecognizerScanner(config: GenericDocumentRecognizerConfiguration): Promise<any>;
     /**
      * Image Operations
      */
     toDataUrl(imageBuffer: ArrayBuffer): Promise<string>;
+    /** @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>;
     /**
-     * @deprecated Use the new ImageProcessor API instead (see {@link createImageProcessor}).
-     */
-    applyFilter(imageBuffer: ArrayBuffer, filterType: ImageFilter): Promise<ArrayBuffer>;
-    rotateImageCcw(imageBuffer: ArrayBuffer, rotations: number): Promise<ArrayBuffer>;
-    cropAndRotateImageCcw(imageBuffer: ArrayBuffer, polygon: Polygon, rotations: number): Promise<any>;
-    detectDocument(imageBuffer: ArrayBuffer, acceptedAngleScore?: number, acceptedSizeScore?: number): Promise<ContourDetectionResult>;
-    detectAndCropDocument(imageBuffer: ArrayBuffer): Promise<ContourDetectionResult>;
-    detectBarcodes(base64: string, engineMode?: EngineMode, barcodeFormats?: BarcodeFormat[], returnBarcodeImage?: boolean): Promise<BarcodeResult>;
+     * @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(options?: {
-        mode: string;
-    }): Promise<OcrEngine>;
-    createDocumentQualityAnalyzer(config?: DocumentQualityAnalyzerConfiguration): Promise<DocumentQualityAnalyzer>;
-    createImageProcessor(imageBuffer: ArrayBuffer): Promise<ImageProcessor>;
+    createOcrEngine(): Promise<OcrEngine>;
+    /** @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>;
     /**
      * Misc. Features
      */
     getLicenseInfo(): Promise<LicenseInfo>;
-    beginPdf(options?: PdfGenerationOptions): Promise<PdfGenerator>;
-    beginTiff(options?: TiffGenerationOptions): Promise<TiffGenerator>;
+    /** @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;
     get utils(): PublicUtils;
-    release(object: any, source?: string): Promise<void>;
+    release(object: ObjectId<any>, source?: string): Promise<void>;
+    /** @internal */
+    getBridge(consumeImage: ConsumeType): {
+        initialize: (licenseKey?: string, engine?: string, appId?: string, cdnPath?: string, options?: {
+            captureConsole?: boolean;
+            allowThreads?: boolean;
+            jpegQuality?: number;
+            requestSuffix?: string;
+        }) => Promise<any>;
+        getLicenseInfo: () => Promise<any>;
+        encodeJpeg: (image: Image) => Promise<Uint8Array>;
+        detectDocument: (image: Image, options: {
+            acceptedAngleScore?: number;
+            acceptedSizeScore?: number;
+            acceptedBrightnessThreshold?: number;
+            requiredAspectRatios?: {
+                readonly width?: number;
+                readonly height?: number;
+                _marker?: () => void;
+            }[];
+            rectangleOfInterest?: Config.Rectangle;
+            _marker?: () => void;
+        }) => Promise<DocumentDetectorTypes.DetectionResult>;
+        detectAndCropDocument: (image: Image) => Promise<CroppedDetectionResult>;
+        createDocumentDetector: (options: {
+            acceptedAngleScore?: number;
+            acceptedSizeScore?: number;
+            acceptedBrightnessThreshold?: number;
+            requiredAspectRatios?: {
+                readonly width?: number;
+                readonly height?: number;
+                _marker?: () => void;
+            }[];
+            rectangleOfInterest?: Config.Rectangle;
+            _marker?: () => void;
+        }) => Promise<ObjectId<"DocumentDetector">>;
+        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?: ({
+                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?: BarcodeScannerTypes.BarcodeDocumentFormat[];
+            returnBarcodeImage?: boolean;
+            _marker?: () => void;
+        }) => Promise<ObjectId<"BarcodeRecognizer">>;
+        recognizeBarcodes: <ImageType_1 extends Image>(barcodeRecognizerToken: ObjectId<"BarcodeRecognizer">, 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;
+                _marker?: () => void;
+            };
+            readonly pageSize?: PdfConfig.PageSize;
+            readonly pageDirection?: PdfConfig.PageDirection;
+            readonly pageFit?: PdfConfig.PageFit;
+            readonly dpi?: number;
+            readonly jpegQuality?: number;
+            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?: TiffTypes.CompressionMode;
+            jpegQuality?: number;
+            zipCompressionLevel?: number;
+            dpi?: number;
+            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?: ParametricFilters.OutputMode;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "CustomBinarizationFilter";
+                outputMode?: ParametricFilters.OutputMode;
+                denoise?: number;
+                radius?: number;
+                preset?: ParametricFilters.BinarizationFilterPreset;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "ColorDocumentFilter";
+                _marker?: () => void;
+            } | {
+                readonly _type?: "BrightnessFilter";
+                brightness?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "ContrastFilter";
+                contrast?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "GrayscaleFilter";
+                borderWidthFraction?: number;
+                blackOutliersFraction?: number;
+                whiteOutliersFraction?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "LegacyFilter";
+                filterType?: number;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "WhiteBlackPointFilter";
+                blackPoint?: number;
+                whitePoint?: number;
+                _marker?: () => void;
+            };
+            _marker?: () => void;
+        }) => Promise<ObjectId<"TiffGenerationContext">>;
+        addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarize: TiffTypes.Binarize) => Promise<unknown>;
+        completeTiff: (tiffOperation: ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
+        createMRZRecognizer: (configuration: {
+            accumulatedResultsVerifierConfig?: {
+                maximumNumberOfAccumulatedFrames?: number;
+                minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
+                _marker?: () => void;
+            };
+            _marker?: () => void;
+        }) => Promise<ObjectId<"MrzRecognizerContext">>;
+        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>;
+        createGenericTextLineScanner: (configuration: {
+            ocrResolutionLimit?: number;
+            maximumNumberOfAccumulatedFrames?: number;
+            minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
+            validator?: {
+                readonly _type?: "DefaultContentValidator";
+                allowedCharacters?: string;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "PresetContentValidator";
+                preset?: "VEHICLE_IDENTIFICATION_NUMBER";
+                _marker?: () => void;
+            } | {
+                readonly _type?: "PatternContentValidator";
+                allowedCharacters?: string;
+                pattern?: string;
+                matchSubstring?: boolean;
+                _marker?: () => void;
+            };
+            _marker?: () => void;
+        }) => Promise<ObjectId<"GenericTextLineScanner">>;
+        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?: {
+                readonly symbolQuality?: number;
+                readonly symbolRatio?: number;
+                _marker?: () => void;
+            }[];
+            readonly qualityIndices?: DocumentQualityAnalyzerTypes.Quality[];
+            readonly maxImageSize?: number;
+            minEstimatedNumberOfSymbolsForDocument?: number;
+            readonly minProcessedFraction?: number;
+            readonly maxProcessedFraction?: number;
+            readonly earlyStopIfNSymbolsFound?: number;
+            readonly tileSize?: number;
+            _marker?: () => void;
+        }) => Promise<ObjectId<"DocumentQualityAnalyzer">>;
+        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: ImageProcessorTypes.ImageRotation) => Promise<RawImage>;
+        genericDocumentRecognizerCreate: (parameters: {
+            resultAccumulationConfig?: {
+                minConfirmations?: number;
+                minConfidenceForStableField?: number;
+                autoClearThreshold?: number;
+                _marker?: () => void;
+            };
+            fieldExcludeList?: 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: <ImageType_4 extends Image>(gdrToken: ObjectId<"GenericDocumentRecognizer">, image: ImageType_4, parameters: {
+            mode?: GenericDocumentRecognizerTypes.RecognitionMode;
+            _marker?: () => void;
+        }) => 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<GenericTextLineScannerTypes.ScannerConfiguration>`} {@link GenericTextLineScannerTypes.ScannerConfiguration}*/
     private createGenericTextLineScanner;
-    static imageFilters: typeof imageFilters;
+    /**
+     * 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/document-quality-analyzer.d.ts

@@ -1,9 +1,11 @@
 import ScanbotSDK from '../scanbot-sdk';
-import DocumentQualityAnalyzerResult from '../model/response/document-quality-analyzer-result';
+import type { DocumentQualityAnalyzerTypes, Image, ObjectId } from '../core-types';
+import { ConsumeType } from "../consume-type";
 export default class DocumentQualityAnalyzer {
-    _token: string;
-    _sdk: ScanbotSDK;
-    constructor(sdk: ScanbotSDK, token: string);
-    analyze(imageData: ArrayBuffer): Promise<DocumentQualityAnalyzerResult>;
+    private _sdk;
+    private _token;
+    /** @internal */
+    constructor(_sdk: ScanbotSDK, _token: ObjectId<"DocumentQualityAnalyzer">);
+    analyze(image: Image, consumeImage?: ConsumeType): Promise<DocumentQualityAnalyzerTypes.AnalysisResult>;
     release(): Promise<void>;
 }