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

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

@@ -0,0 +1,362 @@
+import type { commands } from "../worker/ScanbotSDK.Core";
+export interface WorkerBridgeInitOptions {
+    allowSimd?: boolean;
+    allowThreads?: boolean;
+    requestSuffix?: string;
+}
+export type CoreCommands = typeof commands;
+export declare class WorkerBridge {
+    private instance;
+    private continuations;
+    private nextTicketId;
+    constructor(basePath: string, options: WorkerBridgeInitOptions);
+    private post;
+    private createProxy;
+    readonly copyArgs: {
+        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: import("../worker/ScanbotSDK.Core").Image) => Promise<Uint8Array>;
+        detectDocument: (image: import("../worker/ScanbotSDK.Core").Image, options: {
+            acceptedAngleScore?: number;
+            acceptedSizeScore?: number;
+            acceptedBrightnessThreshold?: number;
+            requiredAspectRatios?: import("./compiled/Geometry").AspectRatio[];
+            rectangleOfInterest?: import("./common").Rectangle;
+            _marker?: () => void;
+        }) => Promise<import("./compiled/DocumentDetectorTypes").DetectionResult>;
+        detectAndCropDocument: (image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("../worker/ScanbotSDK.Core").CroppedDetectionResult>;
+        createDocumentDetector: (options: {
+            acceptedAngleScore?: number;
+            acceptedSizeScore?: number;
+            acceptedBrightnessThreshold?: number;
+            requiredAspectRatios?: import("./compiled/Geometry").AspectRatio[];
+            rectangleOfInterest?: import("./common").Rectangle;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"DocumentDetector">>;
+        documentDetectorDetect: (documentDetectorToken: import("../worker/ScanbotSDK.Core").ObjectId<"DocumentDetector">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/DocumentDetectorTypes").DetectionResult>;
+        parseBarcodeDocument: (options: import("./compiled/BarcodeScannerTypes").BarcodeDocumentFormat[], data: string) => Promise<import("./compiled/GenericDocument").GenericDocument>;
+        createBarcodeRecognizer: (options: {
+            configurators?: import("./compiled/BarcodeConfigs").BarcodeConfig[];
+            engineMode?: import("./compiled/BarcodeScannerTypes").EngineMode;
+            live?: boolean;
+            acceptedDocumentFormats?: import("./compiled/BarcodeScannerTypes").BarcodeDocumentFormat[];
+            returnBarcodeImage?: boolean;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"BarcodeRecognizer">>;
+        recognizeBarcodes: (barcodeRecognizerToken: import("../worker/ScanbotSDK.Core").ObjectId<"BarcodeRecognizer">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/BarcodeScannerTypes").BarcodeScannerResult>;
+        beginPdf: (options: {
+            readonly attributes?: {
+                readonly author?: string;
+                readonly creator?: string;
+                readonly title?: string;
+                readonly subject?: string;
+                readonly keywords?: string;
+                _marker?: () => void;
+            };
+            readonly pageSize?: import("./compiled/PdfConfig").PageSize;
+            readonly pageDirection?: import("./compiled/PdfConfig").PageDirection;
+            readonly pageFit?: import("./compiled/PdfConfig").PageFit;
+            readonly dpi?: number;
+            readonly jpegQuality?: number;
+            readonly resamplingMethod?: import("./compiled/PdfConfig").ResamplingMethod;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"PdfGenerationContext">>;
+        addPageToPdf: (pdfOperation: import("../worker/ScanbotSDK.Core").ObjectId<"PdfGenerationContext">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<void>;
+        completePdf: (pdfOperation: import("../worker/ScanbotSDK.Core").ObjectId<"PdfGenerationContext">) => Promise<Uint8Array>;
+        beginTiff: (options: {
+            compression?: import("./compiled/TiffTypes").CompressionMode;
+            jpegQuality?: number;
+            zipCompressionLevel?: number;
+            dpi?: number;
+            userFields?: import("./compiled/TiffTypes").UserField[];
+            binarizationFilter?: {
+                readonly _type?: "ScanbotBinarizationFilter";
+                outputMode?: import("./compiled/ParametricFilters").OutputMode;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "CustomBinarizationFilter";
+                outputMode?: import("./compiled/ParametricFilters").OutputMode;
+                denoise?: number;
+                radius?: number;
+                preset?: import("./compiled/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<import("../worker/ScanbotSDK.Core").ObjectId<"TiffGenerationContext">>;
+        addPageToTiff: (tiffOperation: import("../worker/ScanbotSDK.Core").ObjectId<"TiffGenerationContext">, image: import("../worker/ScanbotSDK.Core").Image, binarize: import("./compiled/TiffTypes").Binarize) => Promise<unknown>;
+        completeTiff: (tiffOperation: import("../worker/ScanbotSDK.Core").ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
+        createMRZRecognizer: (configuration: {
+            accumulatedResultsVerifierConfig?: {
+                maximumNumberOfAccumulatedFrames?: number;
+                minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
+                _marker?: () => void;
+            };
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"MrzRecognizerContext">>;
+        recognizeMRZ: (mrzRecognizerToken: import("../worker/ScanbotSDK.Core").ObjectId<"MrzRecognizerContext">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/MRZTypes").RecognitionResult>;
+        releaseObject: <T>(objectToken: import("../worker/ScanbotSDK.Core").ObjectId<T>) => Promise<void>;
+        createOcrEngine: () => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"TLDROcrContext">>;
+        performOcr: (tldrOcrToken: import("../worker/ScanbotSDK.Core").ObjectId<"TLDROcrContext">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/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<import("../worker/ScanbotSDK.Core").ObjectId<"GenericTextLineScanner">>;
+        recognizeTextLine: (scannerToken: import("../worker/ScanbotSDK.Core").ObjectId<"GenericTextLineScanner">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/GenericTextLineScannerTypes").ScannerResult>;
+        cleanTextLineRecognitionQueue: (scannerToken: import("../worker/ScanbotSDK.Core").ObjectId<"GenericTextLineScanner">) => Promise<void>;
+        createDocumentQualityAnalyzer: (options: {
+            readonly qualityThresholds?: import("./compiled/DocumentQualityAnalyzerTypes").QualityThreshold[];
+            readonly qualityIndices?: import("./compiled/DocumentQualityAnalyzerTypes").Quality[];
+            readonly maxImageSize?: number;
+            minEstimatedNumberOfSymbolsForDocument?: number;
+            readonly minProcessedFraction?: number;
+            readonly maxProcessedFraction?: number;
+            readonly earlyStopIfNSymbolsFound?: number;
+            readonly tileSize?: number;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"DocumentQualityAnalyzer">>;
+        documentQualityAnalyzerAnalyze: (dqaToken: import("../worker/ScanbotSDK.Core").ObjectId<"DocumentQualityAnalyzer">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/DocumentQualityAnalyzerTypes").AnalysisResult>;
+        imageApplyFilter: (image: import("../worker/ScanbotSDK.Core").Image, filter: import("./common").DeepPartial<import("./compiled/ParametricFilters").ParametricFilter>) => Promise<import("./common").RawImage>;
+        imageCrop: (image: import("../worker/ScanbotSDK.Core").Image, polygon: [import("./common").Point, import("./common").Point, import("./common").Point, import("./common").Point]) => Promise<import("./common").RawImage>;
+        imageResize: (image: import("../worker/ScanbotSDK.Core").Image, destinationSize: number) => Promise<import("./common").RawImage>;
+        imageRotate: (image: import("../worker/ScanbotSDK.Core").Image, rotations: import("./compiled/ImageProcessorTypes").ImageRotation) => Promise<import("./common").RawImage>;
+        genericDocumentRecognizerCreate: (config: {
+            resultAccumulationConfig?: {
+                minConfirmations?: number;
+                minConfidenceForStableField?: number;
+                autoClearThreshold?: number;
+                _marker?: () => void;
+            };
+            fieldExcludeList?: string[];
+            acceptedDocumentTypes?: string[];
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"GenericDocumentRecognizer">>;
+        genericDocumentRecognizerRecognize: (gdrToken: import("../worker/ScanbotSDK.Core").ObjectId<"GenericDocumentRecognizer">, image: import("../worker/ScanbotSDK.Core").Image, parameters: {
+            mode?: import("./compiled/GenericDocumentRecognizerTypes").RecognitionMode;
+            _marker?: () => void;
+        }) => Promise<import("./compiled/GenericDocumentRecognizerTypes").RecognitionResult>;
+        __hasModuleFunction: (functionName: string) => Promise<any>;
+        __callModuleFunction: (functionName: string, args?: any[]) => Promise<any>;
+    };
+    readonly transferArgs: {
+        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: import("../worker/ScanbotSDK.Core").Image) => Promise<Uint8Array>;
+        detectDocument: (image: import("../worker/ScanbotSDK.Core").Image, options: {
+            acceptedAngleScore?: number;
+            acceptedSizeScore?: number;
+            acceptedBrightnessThreshold?: number;
+            requiredAspectRatios?: import("./compiled/Geometry").AspectRatio[];
+            rectangleOfInterest?: import("./common").Rectangle;
+            _marker?: () => void;
+        }) => Promise<import("./compiled/DocumentDetectorTypes").DetectionResult>;
+        detectAndCropDocument: (image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("../worker/ScanbotSDK.Core").CroppedDetectionResult>;
+        createDocumentDetector: (options: {
+            acceptedAngleScore?: number;
+            acceptedSizeScore?: number;
+            acceptedBrightnessThreshold?: number;
+            requiredAspectRatios?: import("./compiled/Geometry").AspectRatio[];
+            rectangleOfInterest?: import("./common").Rectangle;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"DocumentDetector">>;
+        documentDetectorDetect: (documentDetectorToken: import("../worker/ScanbotSDK.Core").ObjectId<"DocumentDetector">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/DocumentDetectorTypes").DetectionResult>;
+        parseBarcodeDocument: (options: import("./compiled/BarcodeScannerTypes").BarcodeDocumentFormat[], data: string) => Promise<import("./compiled/GenericDocument").GenericDocument>;
+        createBarcodeRecognizer: (options: {
+            configurators?: import("./compiled/BarcodeConfigs").BarcodeConfig[];
+            engineMode?: import("./compiled/BarcodeScannerTypes").EngineMode;
+            live?: boolean;
+            acceptedDocumentFormats?: import("./compiled/BarcodeScannerTypes").BarcodeDocumentFormat[];
+            returnBarcodeImage?: boolean;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"BarcodeRecognizer">>;
+        recognizeBarcodes: (barcodeRecognizerToken: import("../worker/ScanbotSDK.Core").ObjectId<"BarcodeRecognizer">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/BarcodeScannerTypes").BarcodeScannerResult>;
+        beginPdf: (options: {
+            readonly attributes?: {
+                readonly author?: string;
+                readonly creator?: string;
+                readonly title?: string;
+                readonly subject?: string;
+                readonly keywords?: string;
+                _marker?: () => void;
+            };
+            readonly pageSize?: import("./compiled/PdfConfig").PageSize;
+            readonly pageDirection?: import("./compiled/PdfConfig").PageDirection;
+            readonly pageFit?: import("./compiled/PdfConfig").PageFit;
+            readonly dpi?: number;
+            readonly jpegQuality?: number;
+            readonly resamplingMethod?: import("./compiled/PdfConfig").ResamplingMethod;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"PdfGenerationContext">>;
+        addPageToPdf: (pdfOperation: import("../worker/ScanbotSDK.Core").ObjectId<"PdfGenerationContext">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<void>;
+        completePdf: (pdfOperation: import("../worker/ScanbotSDK.Core").ObjectId<"PdfGenerationContext">) => Promise<Uint8Array>;
+        beginTiff: (options: {
+            compression?: import("./compiled/TiffTypes").CompressionMode;
+            jpegQuality?: number;
+            zipCompressionLevel?: number;
+            dpi?: number;
+            userFields?: import("./compiled/TiffTypes").UserField[];
+            binarizationFilter?: {
+                readonly _type?: "ScanbotBinarizationFilter";
+                outputMode?: import("./compiled/ParametricFilters").OutputMode;
+                _marker?: () => void;
+            } | {
+                readonly _type?: "CustomBinarizationFilter";
+                outputMode?: import("./compiled/ParametricFilters").OutputMode;
+                denoise?: number;
+                radius?: number;
+                preset?: import("./compiled/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<import("../worker/ScanbotSDK.Core").ObjectId<"TiffGenerationContext">>;
+        addPageToTiff: (tiffOperation: import("../worker/ScanbotSDK.Core").ObjectId<"TiffGenerationContext">, image: import("../worker/ScanbotSDK.Core").Image, binarize: import("./compiled/TiffTypes").Binarize) => Promise<unknown>;
+        completeTiff: (tiffOperation: import("../worker/ScanbotSDK.Core").ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
+        createMRZRecognizer: (configuration: {
+            accumulatedResultsVerifierConfig?: {
+                maximumNumberOfAccumulatedFrames?: number;
+                minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
+                _marker?: () => void;
+            };
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"MrzRecognizerContext">>;
+        recognizeMRZ: (mrzRecognizerToken: import("../worker/ScanbotSDK.Core").ObjectId<"MrzRecognizerContext">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/MRZTypes").RecognitionResult>;
+        releaseObject: <T>(objectToken: import("../worker/ScanbotSDK.Core").ObjectId<T>) => Promise<void>;
+        createOcrEngine: () => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"TLDROcrContext">>;
+        performOcr: (tldrOcrToken: import("../worker/ScanbotSDK.Core").ObjectId<"TLDROcrContext">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/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<import("../worker/ScanbotSDK.Core").ObjectId<"GenericTextLineScanner">>;
+        recognizeTextLine: (scannerToken: import("../worker/ScanbotSDK.Core").ObjectId<"GenericTextLineScanner">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/GenericTextLineScannerTypes").ScannerResult>;
+        cleanTextLineRecognitionQueue: (scannerToken: import("../worker/ScanbotSDK.Core").ObjectId<"GenericTextLineScanner">) => Promise<void>;
+        createDocumentQualityAnalyzer: (options: {
+            readonly qualityThresholds?: import("./compiled/DocumentQualityAnalyzerTypes").QualityThreshold[];
+            readonly qualityIndices?: import("./compiled/DocumentQualityAnalyzerTypes").Quality[];
+            readonly maxImageSize?: number;
+            minEstimatedNumberOfSymbolsForDocument?: number;
+            readonly minProcessedFraction?: number;
+            readonly maxProcessedFraction?: number;
+            readonly earlyStopIfNSymbolsFound?: number;
+            readonly tileSize?: number;
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"DocumentQualityAnalyzer">>;
+        documentQualityAnalyzerAnalyze: (dqaToken: import("../worker/ScanbotSDK.Core").ObjectId<"DocumentQualityAnalyzer">, image: import("../worker/ScanbotSDK.Core").Image) => Promise<import("./compiled/DocumentQualityAnalyzerTypes").AnalysisResult>;
+        imageApplyFilter: (image: import("../worker/ScanbotSDK.Core").Image, filter: import("./common").DeepPartial<import("./compiled/ParametricFilters").ParametricFilter>) => Promise<import("./common").RawImage>;
+        imageCrop: (image: import("../worker/ScanbotSDK.Core").Image, polygon: [import("./common").Point, import("./common").Point, import("./common").Point, import("./common").Point]) => Promise<import("./common").RawImage>;
+        imageResize: (image: import("../worker/ScanbotSDK.Core").Image, destinationSize: number) => Promise<import("./common").RawImage>;
+        imageRotate: (image: import("../worker/ScanbotSDK.Core").Image, rotations: import("./compiled/ImageProcessorTypes").ImageRotation) => Promise<import("./common").RawImage>;
+        genericDocumentRecognizerCreate: (config: {
+            resultAccumulationConfig?: {
+                minConfirmations?: number;
+                minConfidenceForStableField?: number;
+                autoClearThreshold?: number;
+                _marker?: () => void;
+            };
+            fieldExcludeList?: string[];
+            acceptedDocumentTypes?: string[];
+            _marker?: () => void;
+        }) => Promise<import("../worker/ScanbotSDK.Core").ObjectId<"GenericDocumentRecognizer">>;
+        genericDocumentRecognizerRecognize: (gdrToken: import("../worker/ScanbotSDK.Core").ObjectId<"GenericDocumentRecognizer">, image: import("../worker/ScanbotSDK.Core").Image, parameters: {
+            mode?: import("./compiled/GenericDocumentRecognizerTypes").RecognitionMode;
+            _marker?: () => void;
+        }) => Promise<import("./compiled/GenericDocumentRecognizerTypes").RecognitionResult>;
+        __hasModuleFunction: (functionName: string) => Promise<any>;
+        __callModuleFunction: (functionName: string, args?: any[]) => Promise<any>;
+    };
+    destroy(): void;
+}

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

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

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

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

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

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

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

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

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

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

package/@types/index.d.ts

@@ -1,8 +1,5 @@
 export { IDocumentScannerHandle } from "./interfaces/i-document-scanner-handle";
 export { DocumentScannerConfiguration, StyleConfiguration, TextConfiguration, CaptureButtonStyleConfiguration, OutlineStyleConfiguration, HintTextConfiguration, OutlineLabelStyleConfiguration, CaptureAnimationStyleConfiguration, OutlinePolygonStyleConfiguration } from "./model/configuration/document-scanner-configuration";
-export { DocumentDetectionResult } from "./model/document/document-detection-result";
-export { ContourDetectionResult } from "./model/document/contour-detection-result";
-export * as DetectionStatus from "./model/document/detection-status";
 
 export { ViewFinderScannerConfiguration } from "./model/configuration/view-finder-scanner-configuration";
 
@@ -12,32 +9,29 @@ export { CroppingResult } from "./model/response/cropping-result";
 
 export { IBarcodeScannerHandle } from "./interfaces/i-barcode-scanner-handle";
 export { BarcodeScannerConfiguration } from "./model/configuration/barcode-scanner-configuration";
-export { BarcodeResult } from "./model/barcode/barcode-result";
-export { BarcodeFormat } from "./model/barcode/barcode-format";
-export { EngineMode } from "./model/barcode/engine-mode";
 export { BarcodeCountConfiguration, BarcodeCountStyleConfiguration } from "./model/configuration/barcode-count-configuration";
+export { BarcodeScannerResultWithSize } from "./model/barcode/barcode-result";
 
 export { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
 export { MrzScannerConfiguration, MrzScannerAccumulatedFrameVerificationConfiguration } from "./model/configuration/mrz-scanner-configuration";
-export { MrzResult, MrzCheckDigits, MrzField, MRZFieldValidationStatus } from "./model/mrz/mrz-result";
 export * as SimpleMrzRecognizer from "./service/simple-mrz-recognizer";
 
-export { TextDataScannerResult } from './model/generic-text-line-recognizer/text-data-scanner-result';
 export { TextDataScannerConfiguration, TextDetectionCallback } from "./model/configuration/text-data-scanner-configuration";
 export { ITextDataScannerHandle } from "./interfaces/i-text-data-scanner-handle";
 
 export { VINScannerConfiguration } from "./model/configuration/vin-scanner-configuration";
 
+export { GenericDocumentRecognizerConfiguration } from "./model/configuration/generic-document-recognizer-configuration";
+export { default as GenericDocumentRecognizer } from "./service/generic-document-recognizer";
+
+export { PdfGenerator } from "./service/pdf-generator";
+export { TiffGenerator } from "./service/tiff-generator";
+
 export { OcrData, default as OcrEngine, Rect } from "./service/ocr-engine";
 export { Point } from "./utils/dto/Point";
 export { MagneticLine } from "./utils/dto/MagneticLine";
 
-export { ImageProcessor, Rotation } from "./service/image-processor";
-export * as ParametricFilters from "./core/compiled/ParametricFilters";
-
-export { default as DocumentQualityAnalyzerConfiguration } from "./model/configuration/document-quality-analyzer-configuration";
 export { default as DocumentQualityAnalyzer } from "./service/document-quality-analyzer";
-export { default as DocumentQualityAnalyzerResult, DocumentQuality } from "./model/response/document-quality-analyzer-result";
 
 export { default as PublicUtils } from "./service/public-utils";
 export { Size } from "./utils/dto/Size";
@@ -45,16 +39,15 @@ export { VideoSize } from "./utils/dto/VideoSize";
 
 export { SelectionOverlayConfiguration, IBarcodePolygonHandle, IBarcodePolygonLabelHandle, BarcodePolygonStyle, SelectionOverlayTextFormat, SelectionOverlayStyleConfiguration, BarcodePolygonLabelStyle } from "./model/configuration/selection-overlay-configuration";
 
-export { default as PdfGenerator, PdfGenerationOptions, PageDirection, PageSize, PageFit } from "./service/pdf-generator";
-export { default as TiffGenerator, TiffGenerationOptions } from "./service/tiff-generator";
-
-export { BinarizationFilter, ColorFilter, ImageFilter } from "./model/filter-types";
+export { BinarizationFilter, ColorFilter } from "./model/filter-types";
 export { Polygon } from "./utils/dto/Polygon";
-export { Barcode } from "./model/barcode/barcode";
 
 export { InitializationOptions } from "./model/configuration/initialization-options";
 export { LicenseInfo } from "./model/response/license-info";
 export { CameraInfo, CameraFacingMode } from "./model/camera-info";
 
+export { ConsumeType } from "./consume-type";
+
 export { default as ScanbotSDKUI2 } from "./ui2/scanbot-sdk-ui";
-export * as UIConfig from "./ui2/configuration";
+export * as UIConfig from "./ui2/configuration";
+export * as Config from "./core-types";