scanbot-web-sdk 7.0.0-dev.2 → 7.0.0-dev.5

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

@@ -1,7 +1,7 @@
 import { WorkerBridge } from "./worker/worker-bridge";
 import { InitializationOptions } from "./model/configuration/initialization-options";
-import { DocumentScannerConfiguration } from "./model/configuration/document-scanner-configuration";
-import { BarcodeScannerConfiguration } from "./model/configuration/barcode-scanner-configuration";
+import { DocumentScannerViewConfiguration } from "./model/configuration/document-scanner-view-configuration";
+import { BarcodeScannerViewConfiguration } from "./model/configuration/barcode-scanner-view-configuration";
 import { CroppingViewConfiguration } from "./model/configuration/cropping-view-configuration";
 import { LicenseInfo } from "./model/response/license-info";
 import { IDocumentScannerHandle } from "./interfaces/i-document-scanner-handle";
@@ -11,19 +11,19 @@ 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 { MrzScannerConfiguration } from "./model/configuration/mrz-scanner-configuration";
+import { MrzScannerViewConfiguration } from "./model/configuration/mrz-scanner-view-configuration";
 import { IMrzScannerHandle } from "./interfaces/i-mrz-scanner-handle";
 import SimpleMrzRecognizer from "./service/simple-mrz-recognizer";
 import OcrEngine from "./service/ocr-engine";
-import { TextPatternScannerConfiguration } from "./model/configuration/text-pattern-scanner-configuration";
-import { VINScannerConfiguration } from "./model/configuration/vin-scanner-configuration";
+import { TextPatternScannerViewConfiguration } from "./model/configuration/text-pattern-scanner-view-configuration";
+import { VinScannerViewConfiguration } from "./model/configuration/vin-scanner-view-configuration";
 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, TextPatternScannerTypes, VinScannerTypes, TiffTypes, PdfConfigurationTypes, ParametricFilters, ImageTypes, DocumentQualityAnalyzerTypes, MrzTypes, BarcodeScannerTypes, BarcodeDocumentTypes, CroppedDetectionResult, DocumentScannerTypes, DocumentDataExtractorTypes } from "./core-types";
+import { Image, DeepPartial, RawImage, ObjectId, Point, DocumentScannerParameters, DocumentDetectionResult, CroppedDetectionResult, BarcodeScannerConfiguration, BarcodeDocumentFormat, DocumentQualityAnalyzerConfiguration, ImageRotation, ParametricFilter, PdfConfiguration, TiffWriterParameters, DocumentDataExtractorConfiguration } from "./core-types";
 import * as Config from "./core-types";
 import { DocumentDataExtractor } from "./service/document-data-extractor";
-import { DocumentDataExtractorConfiguration } from "./model/configuration/document-data-extractor-configuration";
+import { DocumentDataExtractorViewConfiguration } from "./model/configuration/document-data-extractor-view-configuration";
 import { ConsumeType } from "./consume-type";
 import { Stats } from "./utils/stats";
 import { BrowserCameras } from "./utils/browser-cameras";
@@ -42,34 +42,34 @@ export default class ScanbotSDK {
     /**
      * View Components
      */
-    createDocumentScanner(configuration: DocumentScannerConfiguration): Promise<IDocumentScannerHandle>;
-    createMrzScanner(configuration: MrzScannerConfiguration): Promise<IMrzScannerHandle>;
-    createBarcodeScanner(configuration: BarcodeScannerConfiguration): Promise<IBarcodeScannerHandle>;
+    createDocumentScanner(configuration: DocumentScannerViewConfiguration): Promise<IDocumentScannerHandle>;
+    createMrzScanner(configuration: MrzScannerViewConfiguration): Promise<IMrzScannerHandle>;
+    createBarcodeScanner(configuration: BarcodeScannerViewConfiguration): Promise<IBarcodeScannerHandle>;
     openCroppingView(configuration: CroppingViewConfiguration): Promise<ICroppingViewHandle>;
-    createTextPatternScanner(configuration: TextPatternScannerConfiguration): Promise<ITextPatternScannerHandle>;
-    createVINScanner(configuration: VINScannerConfiguration): Promise<ITextPatternScannerHandle>;
-    createDocumentDataExtractorScanner(config: DocumentDataExtractorConfiguration): Promise<any>;
+    createTextPatternScanner(configuration: TextPatternScannerViewConfiguration): Promise<ITextPatternScannerHandle>;
+    createVinScanner(configuration: VinScannerViewConfiguration): Promise<ITextPatternScannerHandle>;
+    createDocumentDataExtractorScanner(config: DocumentDataExtractorViewConfiguration): Promise<any>;
     /**
      * Image Operations
      */
     toDataUrl(imageBuffer: ArrayBuffer): Promise<string>;
-    /** @param detectionParameters {@displayType `DeepPartial<DocumentScannerTypes.DocumentScannerParameters>`} {@link DocumentScannerTypes.DocumentScannerParameters}*/
-    detectDocument(image: Image, detectionParameters?: DeepPartial<DocumentScannerTypes.DocumentScannerParameters>, consumeImage?: ConsumeType): Promise<DocumentScannerTypes.DocumentDetectionResult>;
+    /** @param detectionParameters {@displayType `DeepPartial<DocumentScannerParameters>`} {@link DocumentScannerParameters}*/
+    detectDocument(image: Image, detectionParameters?: DeepPartial<DocumentScannerParameters>, consumeImage?: ConsumeType): Promise<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.BarcodeScannerConfiguration>, "live">`} {@link BarcodeScannerTypes.BarcodeScannerConfiguration}
+     * @param detectionParameters {@displayType `Omit<DeepPartial<BarcodeScannerConfiguration>, "live">`} {@link BarcodeScannerConfiguration}
      * */
-    detectBarcodes(image: string | Image, partialDetectionParameters?: DeepPartial<Omit<BarcodeScannerTypes.BarcodeScannerConfiguration, "live">>, consumeImage?: ConsumeType): Promise<BarcodeScannerTypes.BarcodeScannerResult & {
+    detectBarcodes(image: string | Image, partialDetectionParameters?: DeepPartial<Omit<BarcodeScannerConfiguration, "live">>, consumeImage?: ConsumeType): Promise<Config.BarcodeScannerResult & {
         originalImage: Image;
     }>;
-    parseBarcodeDocument(acceptedDocumentFormats: BarcodeDocumentTypes.BarcodeDocumentFormat[], rawBarcodeData: string): Promise<Config.GenericDocument.GenericDocument>;
+    parseBarcodeDocument(acceptedDocumentFormats: BarcodeDocumentFormat[], rawBarcodeData: string): Promise<Config.GenericDocument>;
     createSimpleMRZRecognizer(): Promise<SimpleMrzRecognizer>;
     createOcrEngine(): Promise<OcrEngine>;
-    /** @param config {@displayType `DeepPartial<DocumentQualityAnalyzerTypes.DocumentQualityAnalyzerConfiguration>`} {@link DocumentQualityAnalyzerTypes.DocumentQualityAnalyzerConfiguration}*/
-    createDocumentQualityAnalyzer(config?: DeepPartial<DocumentQualityAnalyzerTypes.DocumentQualityAnalyzerConfiguration>): Promise<DocumentQualityAnalyzer>;
-    imageRotate(image: Image, rotation: ImageTypes.ImageRotation, consumeImage?: ConsumeType): Promise<RawImage>;
-    imageFilter(image: Image, filter: ParametricFilters.ParametricFilter, consumeImage?: ConsumeType): Promise<RawImage>;
+    /** @param config {@displayType `DeepPartial<DocumentQualityAnalyzerConfiguration>`} {@link DocumentQualityAnalyzerConfiguration}*/
+    createDocumentQualityAnalyzer(config?: DeepPartial<DocumentQualityAnalyzerConfiguration>): Promise<DocumentQualityAnalyzer>;
+    imageRotate(image: Image, rotation: ImageRotation, consumeImage?: ConsumeType): Promise<RawImage>;
+    imageFilter(image: Image, filter: 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>;
@@ -77,12 +77,12 @@ export default class ScanbotSDK {
      * Misc. Features
      */
     getLicenseInfo(): Promise<LicenseInfo>;
-    /** @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>;
+    /** @param options {@displayType `DeepPartial<PdfConfiguration>`} {@link PdfConfiguration}*/
+    beginPdf(options: DeepPartial<PdfConfiguration>): Promise<PdfGenerator>;
+    /** @param options {@displayType `DeepPartial<TiffWriterParameters>`} {@link TiffWriterParameters} */
+    beginTiff(options?: DeepPartial<TiffWriterParameters>): Promise<TiffGenerator>;
+    /** @param options {@displayType `DeepPartial<DocumentDataExtractorConfiguration>`} {@link DocumentDataExtractorConfiguration}*/
+    createDocumentDataExtractor(options: DeepPartial<DocumentDataExtractorConfiguration>): Promise<DocumentDataExtractor>;
     imageToJpeg(image: Image, consumeImage?: ConsumeType): Promise<Uint8Array>;
     get version(): string;
     private _utils;
@@ -111,7 +111,7 @@ export default class ScanbotSDK {
             }[];
             ignoreOrientationMismatch?: boolean;
             _marker?: () => void;
-        }) => Promise<DocumentScannerTypes.DocumentDetectionResult>;
+        }) => Promise<DocumentDetectionResult>;
         detectAndCropDocument: (image: Image) => Promise<CroppedDetectionResult>;
         createDocumentScanner: (options: {
             isLive?: boolean;
@@ -127,10 +127,10 @@ export default class ScanbotSDK {
             ignoreOrientationMismatch?: boolean;
             _marker?: () => void;
         }) => Promise<ObjectId<"DocumentScanner">>;
-        documentScannerDetect: <ImageType extends Image>(documentScannerToken: ObjectId<"DocumentScanner">, image: ImageType) => Promise<DocumentScannerTypes.DocumentDetectionResult & {
+        documentScannerDetect: <ImageType extends Image>(documentScannerToken: ObjectId<"DocumentScanner">, image: ImageType) => Promise<DocumentDetectionResult & {
             originalImage: ImageType;
         }>;
-        parseBarcodeDocument: (options: BarcodeDocumentTypes.BarcodeDocumentFormat[], data: string) => Promise<Config.GenericDocument.GenericDocument>;
+        parseBarcodeDocument: (options: BarcodeDocumentFormat[], data: string) => Promise<Config.GenericDocument>;
         createBarcodeScanner: (options: {
             barcodeFormatConfigurations?: ({
                 readonly _type?: "BarcodeFormatCodabarConfiguration";
@@ -183,7 +183,7 @@ export default class ScanbotSDK {
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
                 minimum1DQuietZoneSize?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 minimumTextLength?: number;
                 maximumTextLength?: number;
                 _marker?: () => void;
@@ -207,7 +207,7 @@ export default class ScanbotSDK {
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
                 minimum1DQuietZoneSize?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatDataBarExpandedConfiguration";
@@ -215,7 +215,7 @@ export default class ScanbotSDK {
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
                 minimum1DQuietZoneSize?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatDataBarLimitedConfiguration";
@@ -223,7 +223,7 @@ export default class ScanbotSDK {
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
                 minimum1DQuietZoneSize?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatITFConfiguration";
@@ -243,7 +243,7 @@ export default class ScanbotSDK {
                 stripCheckDigits?: boolean;
                 minimumTextLength?: number;
                 maximumTextLength?: number;
-                checksumAlgorithms?: Config.BarcodeConfigurationTypes.MsiPlesseyChecksumAlgorithm[];
+                checksumAlgorithms?: Config.MsiPlesseyChecksumAlgorithm[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatUpcEanConfiguration";
@@ -256,7 +256,7 @@ export default class ScanbotSDK {
                 ean13?: boolean;
                 upca?: boolean;
                 upce?: boolean;
-                extensions?: Config.BarcodeTypes.UpcEanExtensionBehavior;
+                extensions?: Config.UpcEanExtensionBehavior;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatPharmaCodeConfiguration";
@@ -273,14 +273,14 @@ export default class ScanbotSDK {
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatQRCodeConfiguration";
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
                 qr?: boolean;
                 microQr?: boolean;
@@ -291,7 +291,7 @@ export default class ScanbotSDK {
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
                 _marker?: () => void;
             } | {
@@ -299,7 +299,7 @@ export default class ScanbotSDK {
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
                 _marker?: () => void;
             } | {
@@ -307,7 +307,7 @@ export default class ScanbotSDK {
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatMaxiCodeConfiguration";
@@ -320,7 +320,7 @@ export default class ScanbotSDK {
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                australiaPostCustomerFormat?: Config.BarcodeConfigurationTypes.AustraliaPostCustomerFormat;
+                australiaPostCustomerFormat?: Config.AustraliaPostCustomerFormat;
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatJapanPostConfiguration";
@@ -360,7 +360,7 @@ export default class ScanbotSDK {
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
                 minimum1DQuietZoneSize?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
                 _marker?: () => void;
             } | {
@@ -372,25 +372,25 @@ export default class ScanbotSDK {
                 stripCheckDigits?: boolean;
                 minimumTextLength?: number;
                 maximumTextLength?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
-                formats?: Config.BarcodeTypes.BarcodeFormat[];
+                formats?: Config.BarcodeFormat[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonTwoDConfiguration";
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
-                formats?: Config.BarcodeTypes.BarcodeFormat[];
+                formats?: Config.BarcodeFormat[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonFourStateConfiguration";
                 regexFilter?: string;
                 minimumSizeScore?: number;
                 addAdditionalQuietZone?: boolean;
-                formats?: Config.BarcodeTypes.BarcodeFormat[];
+                formats?: Config.BarcodeFormat[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "BarcodeFormatCommonConfiguration";
@@ -401,19 +401,19 @@ export default class ScanbotSDK {
                 stripCheckDigits?: boolean;
                 minimumTextLength?: number;
                 maximumTextLength?: number;
-                gs1Handling?: Config.BarcodeTypes.Gs1Handling;
+                gs1Handling?: Config.Gs1Handling;
                 strictMode?: boolean;
-                formats?: Config.BarcodeTypes.BarcodeFormat[];
+                formats?: Config.BarcodeFormat[];
                 _marker?: () => void;
             })[];
-            extractedDocumentFormats?: BarcodeDocumentTypes.BarcodeDocumentFormat[];
+            extractedDocumentFormats?: BarcodeDocumentFormat[];
             onlyAcceptDocuments?: boolean;
             returnBarcodeImage?: boolean;
-            engineMode?: BarcodeScannerTypes.BarcodeScannerEngineMode;
+            engineMode?: Config.BarcodeScannerEngineMode;
             live?: boolean;
             _marker?: () => void;
         }) => Promise<ObjectId<"BarcodeScanner">>;
-        scanBarcodes: <ImageType_1 extends Image>(barcodeScannerToken: ObjectId<"BarcodeScanner">, image: ImageType_1) => Promise<BarcodeScannerTypes.BarcodeScannerResult & {
+        scanBarcodes: <ImageType_1 extends Image>(barcodeScannerToken: ObjectId<"BarcodeScanner">, image: ImageType_1) => Promise<Config.BarcodeScannerResult & {
             originalImage: ImageType_1;
         }>;
         beginPdf: (options: {
@@ -425,18 +425,18 @@ export default class ScanbotSDK {
                 keywords?: string;
                 _marker?: () => void;
             };
-            pageSize?: PdfConfigurationTypes.PageSize;
-            pageDirection?: PdfConfigurationTypes.PageDirection;
-            pageFit?: PdfConfigurationTypes.PageFit;
+            pageSize?: Config.PageSize;
+            pageDirection?: Config.PageDirection;
+            pageFit?: Config.PageFit;
             dpi?: number;
             jpegQuality?: number;
-            resamplingMethod?: PdfConfigurationTypes.ResamplingMethod;
+            resamplingMethod?: Config.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;
+            compression?: Config.CompressionMode;
             jpegQuality?: number;
             zipCompressionLevel?: number;
             dpi?: number;
@@ -460,14 +460,14 @@ export default class ScanbotSDK {
             }[];
             binarizationFilter?: {
                 readonly _type?: "ScanbotBinarizationFilter";
-                outputMode?: ParametricFilters.OutputMode;
+                outputMode?: Config.OutputMode;
                 _marker?: () => void;
             } | {
                 readonly _type?: "CustomBinarizationFilter";
-                outputMode?: ParametricFilters.OutputMode;
+                outputMode?: Config.OutputMode;
                 denoise?: number;
                 radius?: number;
-                preset?: ParametricFilters.BinarizationFilterPreset;
+                preset?: Config.BinarizationFilterPreset;
                 _marker?: () => void;
             } | {
                 readonly _type?: "ColorDocumentFilter";
@@ -498,7 +498,7 @@ export default class ScanbotSDK {
             };
             _marker?: () => void;
         }) => Promise<ObjectId<"TiffGenerationContext">>;
-        addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarization: TiffTypes.Binarization) => Promise<unknown>;
+        addPageToTiff: (tiffOperation: ObjectId<"TiffGenerationContext">, image: Image, binarization: Config.Binarization) => Promise<unknown>;
         completeTiff: (tiffOperation: ObjectId<"TiffGenerationContext">) => Promise<Uint8Array>;
         createMRZScanner: (configuration: {
             frameAccumulationConfiguration?: {
@@ -507,15 +507,15 @@ export default class ScanbotSDK {
                 _marker?: () => void;
             };
             enableDetection?: boolean;
-            incompleteResultHandling?: MrzTypes.MrzIncompleteResultHandling;
+            incompleteResultHandling?: Config.MrzIncompleteResultHandling;
             _marker?: () => void;
         }) => Promise<ObjectId<"MRZScannerContext">>;
-        scanMRZ: <ImageType_2 extends Image>(mrzScannerToken: ObjectId<"MRZScannerContext">, image: ImageType_2) => Promise<MrzTypes.MrzScannerResult & {
+        scanMRZ: <ImageType_2 extends Image>(mrzScannerToken: ObjectId<"MRZScannerContext">, image: ImageType_2) => Promise<Config.MrzScannerResult & {
             originalImage: ImageType_2;
         }>;
         releaseObject: <T>(objectToken: ObjectId<T>) => Promise<void>;
         createOcrEngine: () => Promise<ObjectId<"TLDROcrContext">>;
-        performOcr: (tldrOcrToken: ObjectId<"TLDROcrContext">, image: Image) => Promise<Config.OcrTypes.Page>;
+        performOcr: (tldrOcrToken: ObjectId<"TLDROcrContext">, image: Image) => Promise<Config.Page>;
         createTextPatternScanner: (configuration: {
             ocrResolutionLimit?: number;
             maximumNumberOfAccumulatedFrames?: number;
@@ -533,7 +533,7 @@ export default class ScanbotSDK {
             };
             _marker?: () => void;
         }) => Promise<ObjectId<"TextPatternScanner">>;
-        scanTextLine: <ImageType_3 extends Image>(scannerToken: ObjectId<"TextPatternScanner">, image: ImageType_3) => Promise<TextPatternScannerTypes.TextPatternScannerResult & {
+        scanTextLine: <ImageType_3 extends Image>(scannerToken: ObjectId<"TextPatternScanner">, image: ImageType_3) => Promise<Config.TextPatternScannerResult & {
             originalImage: ImageType_3;
         }>;
         cleanTextLineScanningQueue: (scannerToken: ObjectId<"TextPatternScanner">) => Promise<void>;
@@ -544,7 +544,7 @@ export default class ScanbotSDK {
             minimumNumberOfRequiredFramesWithEqualRecognitionResult?: number;
             _marker?: () => void;
         }) => Promise<ObjectId<"VinScanner">>;
-        scanVin: <ImageType_4 extends Image>(scannerToken: ObjectId<"VinScanner">, image: ImageType_4) => Promise<VinScannerTypes.VinScannerResult & {
+        scanVin: <ImageType_4 extends Image>(scannerToken: ObjectId<"VinScanner">, image: ImageType_4) => Promise<Config.VinScannerResult & {
             originalImage: ImageType_4;
         }>;
         cleanVinScanningQueue: (scannerToken: ObjectId<"VinScanner">) => Promise<void>;
@@ -554,7 +554,7 @@ export default class ScanbotSDK {
                 readonly symbolRatio?: number;
                 _marker?: () => void;
             }[];
-            qualityIndices?: DocumentQualityAnalyzerTypes.DocumentQuality[];
+            qualityIndices?: Config.DocumentQuality[];
             detectOrientation?: boolean;
             maxImageSize?: number;
             minEstimatedNumberOfSymbolsForDocument?: number;
@@ -564,14 +564,14 @@ export default class ScanbotSDK {
             tileSize?: number;
             _marker?: () => void;
         }) => Promise<ObjectId<"DocumentQualityAnalyzer">>;
-        documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<DocumentQualityAnalyzerTypes.DocumentQualityAnalyzerResult>;
-        imageApplyFilter: (image: Image, filter: DeepPartial<ParametricFilters.ParametricFilter>) => Promise<RawImage>;
+        documentQualityAnalyzerAnalyze: (dqaToken: ObjectId<"DocumentQualityAnalyzer">, image: Image) => Promise<Config.DocumentQualityAnalyzerResult>;
+        imageApplyFilter: (image: Image, filter: DeepPartial<ParametricFilter>) => Promise<RawImage>;
         imageCrop: (image: Image, polygon: [Point, Point, Point, Point]) => Promise<RawImage>;
         imageResize: (image: Image, destinationSize: number) => Promise<RawImage>;
-        imageRotate: (image: Image, rotations: ImageTypes.ImageRotation) => Promise<RawImage>;
+        imageRotate: (image: Image, rotations: ImageRotation) => Promise<RawImage>;
         documentDataExtractorCreate: (parameters: {
             resultAccumulationConfig?: {
-                confirmationMethod?: Config.FrameAccumulationTypes.ConfirmationMethod;
+                confirmationMethod?: Config.ConfirmationMethod;
                 minConfirmations?: number;
                 minConfidenceForStableField?: number;
                 autoClearThreshold?: number;
@@ -586,12 +586,12 @@ export default class ScanbotSDK {
                 _marker?: () => void;
             } | {
                 readonly _type?: "EuropeanHealthInsuranceCardConfiguration";
-                expectedCountry?: Config.DocumentDataExtractorConfigurationTypes.EuropeanHealthInsuranceCardIssuingCountry;
+                expectedCountry?: Config.EuropeanHealthInsuranceCardIssuingCountry;
                 _marker?: () => void;
             } | {
                 readonly _type?: "MRZFallbackConfiguration";
                 acceptedCountries?: string[];
-                acceptedMRZTypes?: MrzTypes.MrzDocumentType[];
+                acceptedMRZTypes?: Config.MrzDocumentType[];
                 _marker?: () => void;
             } | {
                 readonly _type?: "DocumentDataExtractorCommonConfiguration";
@@ -601,9 +601,9 @@ export default class ScanbotSDK {
             _marker?: () => void;
         }) => Promise<ObjectId<"DocumentDataExtractor">>;
         documentDataExtractorExtract: <ImageType_5 extends Image>(gdrToken: ObjectId<"DocumentDataExtractor">, image: ImageType_5, parameters: {
-            mode?: DocumentDataExtractorTypes.DocumentDataExtractionMode;
+            mode?: Config.DocumentDataExtractionMode;
             _marker?: () => void;
-        }) => Promise<DocumentDataExtractorTypes.DocumentDataExtractionResult & {
+        }) => Promise<Config.DocumentDataExtractionResult & {
             originalImage: ImageType_5;
         }>;
         version: () => Promise<string>;

package/@types/service/document-data-extractor.d.ts

@@ -1,12 +1,12 @@
 import ScanbotSDK from '../scanbot-sdk';
-import { ObjectId, Image, DocumentDataExtractorTypes, DeepPartial } from "../core-types";
+import { ObjectId, Image, DeepPartial, DocumentDataFrameExtractionParameters } from "../core-types";
 import { ConsumeType } from "../consume-type";
 export declare class DocumentDataExtractor {
     private _sdk;
     private _recognizer;
     /** @internal */
     constructor(_sdk: ScanbotSDK, _recognizer: ObjectId<"DocumentDataExtractor">);
-    recognize<ImageType extends Image>(image: ImageType, parameters: DeepPartial<DocumentDataExtractorTypes.DocumentDataFrameExtractionParameters>, consumeImage?: ConsumeType): Promise<DocumentDataExtractorTypes.DocumentDataExtractionResult & {
+    recognize<ImageType extends Image>(image: ImageType, parameters: DeepPartial<DocumentDataFrameExtractionParameters>, consumeImage?: ConsumeType): Promise<import("../core-types").DocumentDataExtractionResult & {
         originalImage: ImageType;
     }>;
     release(): Promise<void>;

package/@types/service/document-quality-analyzer.d.ts

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

package/@types/service/ocr-engine.d.ts

@@ -1,5 +1,5 @@
 import ScanbotSDK from '../scanbot-sdk';
-import type { Image, ObjectId, OcrTypes } from "../core-types";
+import { Image, ObjectId, Page } from "../core-types";
 import { ConsumeType } from "../consume-type";
 export interface Rect {
     x: number;
@@ -17,7 +17,7 @@ export default class OcrEngine {
     private _OcrEngineToken;
     /** @internal */
     constructor(_sdk: ScanbotSDK, _OcrEngineToken: ObjectId<"TLDROcrContext">);
-    performOcr(image: Image, consumeImage?: ConsumeType): Promise<OcrTypes.Page>;
-    recognizeURL(imageURL: string): Promise<OcrTypes.Page>;
+    performOcr(image: Image, consumeImage?: ConsumeType): Promise<Page>;
+    recognizeURL(imageURL: string): Promise<Page>;
     release(): Promise<void>;
 }

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

@@ -1,13 +1,13 @@
 import ScanbotSDK from '../scanbot-sdk';
-import type { ObjectId, MrzTypes, Image } from "../core-types";
+import type { ObjectId, Image, MrzScannerResult } from "../core-types";
 import { ConsumeType } from "../consume-type";
 export default class SimpleMrzRecognizer {
     private _sdk;
     private _mrzRecognizerToken;
     constructor(_sdk: ScanbotSDK, _mrzRecognizerToken: Promise<ObjectId<"MRZScannerContext">>);
-    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<MrzTypes.MrzScannerResult & {
+    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<MrzScannerResult & {
         originalImage: ImageType;
     }>;
-    recognizeURL(imageURL: string): Promise<MrzTypes.MrzScannerResult | undefined>;
+    recognizeURL(imageURL: string): Promise<MrzScannerResult | undefined>;
     release(): Promise<void>;
 }

package/@types/service/text-pattern-scanner.d.ts

@@ -1,14 +1,14 @@
 import ScanbotSDK from '../scanbot-sdk';
-import { ObjectId, Image, TextPatternScannerTypes } from '../core-types';
+import { ObjectId, Image, TextPatternScannerResult } from '../core-types';
 import { ConsumeType } from "../consume-type";
 export default class TextPatternScanner {
     private _sdk;
     private _textPatternScannerToken;
     constructor(_sdk: ScanbotSDK, _textPatternScannerToken: Promise<ObjectId<"TextPatternScanner">>);
-    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<TextPatternScannerTypes.TextPatternScannerResult & {
+    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<TextPatternScannerResult & {
         originalImage: ImageType;
     }>;
     cleanRecognitionQueue(): Promise<void>;
-    recognizeURL(imageURL: string): Promise<TextPatternScannerTypes.TextPatternScannerResult>;
+    recognizeURL(imageURL: string): Promise<TextPatternScannerResult>;
     release(): Promise<void>;
 }

package/@types/service/tiff-generator.d.ts

@@ -1,9 +1,9 @@
 import ScanbotSDK from '../scanbot-sdk';
-import type { ObjectId, Image, TiffTypes } from "../core-types";
+import type { ObjectId, Image, Binarization } from "../core-types";
 import { ConsumeType } from "../consume-type";
 import { SBDocument } from "../ui2/document/model/sb-document";
 export interface TiffPageOptions {
-    binarize?: TiffTypes.Binarization;
+    binarize?: Binarization;
     consumeImage?: ConsumeType;
 }
 export declare class TiffGenerator {

package/@types/service/vin-scanner.d.ts

@@ -1,15 +1,15 @@
 import ScanbotSDK from '../scanbot-sdk';
-import { ObjectId, Image, VinScannerTypes } from '../core-types';
+import { ObjectId, Image } from '../core-types';
 import { ConsumeType } from "../consume-type";
 export default class VinScanner {
     private _sdk;
     private _token;
     constructor(_sdk: ScanbotSDK, _token: Promise<ObjectId<"VinScanner">>);
-    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<VinScannerTypes.VinScannerResult & {
+    recognize<ImageType extends Image>(image: ImageType, consumeImage?: ConsumeType): Promise<import("../core-types").VinScannerResult & {
         originalImage: ImageType;
     }>;
     cleanRecognitionQueue(): Promise<void>;
-    recognizeURL(imageURL: string): Promise<VinScannerTypes.VinScannerResult & {
+    recognizeURL(imageURL: string): Promise<import("../core-types").VinScannerResult & {
         originalImage: ImageData;
     }>;
     release(): Promise<void>;

package/@types/ui2/barcode/controllers/barcode-scanner-controller.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { BarcodeScannerConfiguration, BarcodeScannerUIResult } from '../../configuration';
+import { BarcodeScannerConfiguration, BarcodeScannerUiResult } from '../../configuration';
 export declare class Props {
     configuration: BarcodeScannerConfiguration;
     onClose: () => void;
-    onSubmit: (barcodeScannerResult: BarcodeScannerUIResult) => void;
+    onSubmit: (barcodeScannerResult: BarcodeScannerUiResult) => void;
     onError: (error: Error) => void;
 }
 export declare function BarcodeScannerController(props: Props): React.JSX.Element;

package/@types/ui2/barcode/controllers/multiple-scanning-mode-controller.d.ts

@@ -1,10 +1,10 @@
 import React from "react";
-import { BarcodeScannerConfiguration, BarcodeScannerUIResult } from "../../configuration";
+import { BarcodeScannerUiResult, BarcodeScannerConfiguration } from "../../configuration";
 import { IBarcodeMapper } from "../utils/barcode-mapper/i-barcode-mapper";
 declare class Props {
     configuration: BarcodeScannerConfiguration;
     onCameraPermissionDenied: () => void;
-    onSubmit: (barcodeScannerResult: BarcodeScannerUIResult) => void;
+    onSubmit: (barcodeScannerResult: BarcodeScannerUiResult) => void;
     onError: (error?: Error) => void;
     scanningEnabled: React.MutableRefObject<boolean>;
     barcodeMapper: IBarcodeMapper;

package/@types/ui2/barcode/controllers/single-scanning-mode-controller.d.ts

@@ -1,10 +1,10 @@
 import React from "react";
-import { BarcodeScannerConfiguration, BarcodeScannerUIResult } from "../../configuration";
+import { BarcodeScannerConfiguration, BarcodeScannerUiResult } from "../../configuration";
 import { IBarcodeMapper } from "../utils/barcode-mapper/i-barcode-mapper";
 declare class Props {
     configuration: BarcodeScannerConfiguration;
     onClose: () => void;
-    onSubmit: (barcodeScannerUIResult: BarcodeScannerUIResult) => void;
+    onSubmit: (barcodeScannerUIResult: BarcodeScannerUiResult) => void;
     onError: (error?: Error) => void;
     onCameraPermissionDenied: () => void;
     scanningEnabled: React.MutableRefObject<boolean>;

package/@types/ui2/barcode/utils/camera-config.d.ts

@@ -1,3 +1,3 @@
-import { BarcodeScannerConfiguration as BarcodeScannerViewConfig } from "../../../model/configuration/barcode-scanner-configuration";
+import { BarcodeScannerViewConfiguration as BarcodeScannerViewConfig } from "../../../model/configuration/barcode-scanner-view-configuration";
 import { BarcodeScannerConfiguration } from "../../configuration/barcode/BarcodeScannerConfiguration";
 export declare function barcodeScannerViewConfigFromRtuUiConfig(config: BarcodeScannerConfiguration): Partial<BarcodeScannerViewConfig>;

package/@types/ui2/barcode/utils/styled-button.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { ButtonConfiguration } from "../../configuration";
-export interface ButtonProps extends ButtonConfiguration {
+export interface ButtonProps extends Omit<ButtonConfiguration, "accessibilityDescription"> {
     onClick: React.MouseEventHandler<HTMLButtonElement>;
     icon?: React.ReactNode;
     debugName?: string;

package/@types/ui2/barcode/views/action-button/action-button-container.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 import BarcodeScannerView from "../../../../barcode-scanner-view";
-import { ActionBarConfiguration } from "../../../configuration/barcode/ActionBarConfiguration";
-import { CameraModule } from "../../../configuration/barcode/CameraConfiguration";
+import type { ActionBarConfiguration } from "../../../configuration/common/ActionBarConfiguration";
+import type { CameraModule } from "../../../configuration/common/CameraConfiguration";
 export type Facingmode = "environment" | "user";
 export declare class Props {
     capabilities?: ActionButtonCapabilities;