scanbot-web-sdk 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -10,7 +10,7 @@ import ScannedImageWithOverlay from "./view/barcode-calculation/scanned-image-wi
 import { BarcodeScannerViewConfiguration } from "./model/configuration/barcode-scanner-view-configuration";
 import { Size } from "./utils/dto/Size";
 import { BarcodeItem } from "./core-types";
-import { BarcodeScanner } from "./core/compiled/bridge/BarcodeScanner";
+import type { ObjectId } from "./core-types";
 export declare class BarcodeScannerProps extends ScanbotCameraProps {
 }
 export declare class BarcodeScannerState extends ScanbotCameraState {
@@ -28,7 +28,7 @@ export default class BarcodeScannerView extends ScannerView<BarcodeScannerProps,
     popup: BarcodeCalculationPopup | undefined;
     scannedImage: ScannedImageWithOverlay | undefined;
     bottomActionBar: BottomActionBar | undefined;
-    barcodeScannerHandle: BarcodeScanner | null;
+    handle: ObjectId<"BarcodeScanner"> | null;
     readonly barcodes: BarcodeItem[];
     private detectionRunning;
     constructor(props: BarcodeScannerProps);
@@ -42,7 +42,6 @@ export default class BarcodeScannerView extends ScannerView<BarcodeScannerProps,
     resumeDetection(): Promise<void>;
     pauseDetection(): void;
     private readonly updateDimensionsCallback;
-    onSdkReady(): Promise<void>;
     /**
      * React Overrides
      */

package/@types/core/{compiled → bridge/compiled}/BarcodeDocumentModel.d.ts

@@ -76,17 +76,13 @@ export declare class BoardingPass {
     constructor(document: GenericDocument);
     requiredDocumentType(): string;
     /** Electronic Ticket */
-    get electronicTicketIndicator(): Field;
-    /** Format Code. */
-    get formatCode(): Field;
-    /** Number of encoded legs. */
+    get electronicTicket(): Field;
+    /** Name */
+    get name(): Field;
+    /** Number Of Legs */
     get numberOfLegs(): Field;
-    /** Passenger Name */
-    get passengerName(): Field;
     /** Security Data */
-    get securityData(): Field | undefined;
-    /** Security Data Type */
-    get securityDataType(): Field | undefined;
+    get securityData(): Field;
     /** An array of all children of type "Leg". */
     get legs(): BoardingPass.Leg[];
 }

package/@types/core/{compiled → bridge/compiled}/BarcodeDocumentTypes.d.ts

@@ -1,6 +1,5 @@
 import { BarcodeFormat } from "./BarcodeTypes";
 import { DeepPartial, PartiallyConstructible } from "./utils";
-import { GenericDocument } from "./GenericDocument";
 /**
 Type of barcode document format used.
 
@@ -59,18 +58,3 @@ export declare namespace BarcodeDocumentFormats {
         [key in BarcodeDocumentFormat]: BarcodeFormat[];
     };
 }
-/**
-The result of barcode document parsing.
-*/
-export declare class BarcodeDocumentParserResult extends PartiallyConstructible {
-    /**
-    True if any document was parsed
-    */
-    readonly success: boolean;
-    /**
-    In case of success, the parsed document
-    */
-    readonly parsedDocument: GenericDocument | null;
-    /** @param source {@displayType `DeepPartial<BarcodeDocumentParserResult>`} */
-    constructor(source?: DeepPartial<BarcodeDocumentParserResult>);
-}

package/@types/core/{compiled → bridge/compiled}/BarcodeScannerTypes.d.ts

@@ -3,11 +3,8 @@ import { BarcodeFormatConfigurationBase } from "./BarcodeConfigurationTypes";
 import { BarcodeFormat } from "./BarcodeTypes";
 import { DeepPartial, PartiallyConstructible } from "./utils";
 import { GenericDocument } from "./GenericDocument";
-import { Image } from "./bridge/image";
 import { Point } from "./utils";
-import { ProcessingMode } from "./CommonTypes";
-import { RangeEncoding } from "./BarcodeTypes";
-import { StructuredAppendInfo } from "./BarcodeTypes";
+import { RawImage } from "./utils";
 /**
 A single barcode found in the input image. Barcodes with the same content but different locations in the image are considered separate barcodes.
 */
@@ -17,24 +14,6 @@ export declare class BarcodeItem extends PartiallyConstructible {
     */
     readonly text: string;
     /**
-    Raw bytes of barcode contents.
-    Some barcode formats are able to encode binary data. If a barcode contains binary data, it's provided as a list of bytes in the rawBytes field.
-    Some barcode formats additionally allow pieces of the data within to have different encodings - UTF-8, ASCII, binary, etc.
-    The rawBytesEncodings field lists the encoding of each range in the rawBytes array.
-    For barcode formats that contain a GS1 message (e.g. GS1 Composite), we recommend to use a GS1Handling and extract the GS1 message from the text.
-    */
-    readonly rawBytes: Uint8Array;
-    /**
-    Encoding information for the rawBytes field. Each element of this list covers some portion of the rawBytes array.
-    Taken together, the elements of the list cover the entirety of the rawBytes array without overlap and without holes.
-    The elements are ordered in increasing order of the start and end indices.
-    */
-    readonly rawBytesEncodings: RangeEncoding[];
-    /**
-    If this barcode is part of a structured append sequence, this field contains information about the sequence.
-    */
-    readonly structuredAppendInfo: StructuredAppendInfo | null;
-    /**
     Barcode format.
     @defaultValue "NONE";
     */
@@ -56,7 +35,11 @@ export declare class BarcodeItem extends PartiallyConstructible {
     A crop from the input image containing the barcode.
     @defaultValue null;
     */
-    readonly sourceImage: Image | null;
+    readonly sourceImage: RawImage | null;
+    /**
+    Raw bytes of barcode contents. Some formats can contain binary data, which is returned in this field.
+    */
+    readonly rawBytes: Uint8Array;
     /**
     If this is a UPC/EAN barcode that has an EAN-2 or EAN-5 extension, this field contains the extension value. Requires the UPC_EAN_EXTENSION format to be enabled in the decoding options.
     */
@@ -89,12 +72,6 @@ export declare class BarcodeItem extends PartiallyConstructible {
     The parsed known document format (if parsed successfully).
     */
     readonly extractedDocument: GenericDocument | null;
-    /**
-    The index of the barcode to uniquely identify it.
-    In case of frame accumulation, the index remains the same across frames.
-    @defaultValue -1;
-    */
-    readonly globalIndex: number;
     /** @param source {@displayType `DeepPartial<BarcodeItem>`} */
     constructor(source?: DeepPartial<BarcodeItem>);
 }
@@ -110,51 +87,11 @@ The engine mode for barcode scanning.
 - `NEXT_GEN_LOW_POWER_FAR_DISTANCE`:
    Similar to NEXT_GEN_LOW_POWER, but optimized for scanning from far distances.
 - `NEXT_GEN_FAR_DISTANCE`:
-   Similar to NEXT_GEN, but optimized for scanning from far distances.
+   Similar to NEXT_GEN, optimized for scanning from far distances.
 */
 export type BarcodeScannerEngineMode = "LEGACY" | "NEXT_GEN_LOW_POWER" | "NEXT_GEN" | "NEXT_GEN_LOW_POWER_FAR_DISTANCE" | "NEXT_GEN_FAR_DISTANCE";
 export declare const BarcodeScannerEngineModeValues: BarcodeScannerEngineMode[];
 /**
-The method how to display barcodes from previous frames.
-
-- `LAST_VISIBLE`:
-   The quad of a barcode is simply given as the last quad when it was detected.
-- `INTERPOLATE_BY_CAMERA`:
-   The quad of barcode is interpolated by the camera movement. This option is recommended when the camera is moving, but the scanned object is not.
-*/
-export type BarcodeAccumulationMethod = "LAST_VISIBLE" | "INTERPOLATE_BY_CAMERA";
-export declare const BarcodeAccumulationMethodValues: BarcodeAccumulationMethod[];
-/**
-Configuration for how to accumulate results.
-*/
-export declare class BarcodeAccumulationConfiguration extends PartiallyConstructible {
-    /**
-    In case that ean/upc both with and without extensions are allowed,
-    we require confirmations to consider a standalone EAN or UPC (i.e. without extension) as valid.
-    @defaultValue 2;
-    */
-    minConfirmationsStandaloneEAN: number;
-    /**
-    Maximum number of accumulated frames to inspect to verify a scan result.
-    @defaultValue 5;
-    */
-    maximumNumberOfAccumulatedFrames: number;
-    /**
-    If true, the results from previous frames that are not connected to results on the current frame will be removed.
-    This is should be enabled when large camera movements are expected.
-    For small camera movements, the option can be disabled.
-    @defaultValue true;
-    */
-    removeUnconnectedResults: boolean;
-    /**
-    The method how to display barcodes from previous frames.
-    @defaultValue "INTERPOLATE_BY_CAMERA";
-    */
-    method: BarcodeAccumulationMethod;
-    /** @param source {@displayType `DeepPartial<BarcodeAccumulationConfiguration>`} */
-    constructor(source?: DeepPartial<BarcodeAccumulationConfiguration>);
-}
-/**
 Configuration for the barcode scanner.
 */
 export declare class BarcodeScannerConfiguration extends PartiallyConstructible {
@@ -188,24 +125,11 @@ export declare class BarcodeScannerConfiguration extends PartiallyConstructible
     */
     engineMode: BarcodeScannerEngineMode;
     /**
-    Configuration to accumulate barcodes across multiple frames in live mode.
-    @defaultValue new BarcodeAccumulationConfiguration({});
-    */
-    accumulationConfig: BarcodeAccumulationConfiguration;
-    /**
     If true, the quads of linear (1D) barcodes will be further refined to more closely match the barcode's outline in the input image.
     This will also produce stabler barcode outlines across frames for use cases such as AR.
     @defaultValue false;
     */
     optimizedForOverlays: boolean;
-    /**
-    Scanners typically can produce better results from a single image if they are allowed to spend a longer time analyzing it.
-    
-    On the other hand, scanners can produce even better results if they can analyze multiple images of the same subject and cross-check and combine the results.
-    The processing mode tells the scanner whether to optimize for single or multiple images of a subject.
-    @defaultValue "AUTO";
-    */
-    processingMode: ProcessingMode;
     /** @param source {@displayType `DeepPartial<BarcodeScannerConfiguration>`} */
     constructor(source?: DeepPartial<BarcodeScannerConfiguration>);
 }

package/@types/core/{compiled → bridge/compiled}/BarcodeTypes.d.ts

@@ -1,117 +1,5 @@
 import { DeepPartial, PartiallyConstructible } from "./utils";
 /**
-Enumerates character encodings.
-
-- `UNKNOWN`:
-   Unknown encoding.
-- `ASCII`:
-   ASCII (ISO 646).
-- `ISO_8859_PART1`:
-   ISO/IEC 8859 Part 1, a.k.a. Latin-1 Western European.
-- `ISO_8859_PART2`:
-   ISO/IEC 8859 Part 2, a.k.a. Latin-2 Central European.
-- `ISO_8859_PART3`:
-   ISO/IEC 8859 Part 3, a.k.a. Latin-3 South European.
-- `ISO_8859_PART4`:
-   ISO/IEC 8859 Part 4, a.k.a. Latin-4 North European.
-- `ISO_8859_PART5`:
-   ISO/IEC 8859 Part 5, a.k.a. Latin/Cyrillic.
-- `ISO_8859_PART6`:
-   ISO/IEC 8859 Part 6, a.k.a. Latin/Arabic.
-- `ISO_8859_PART7`:
-   ISO/IEC 8859 Part 7, a.k.a. Latin/Greek.
-- `ISO_8859_PART8`:
-   ISO/IEC 8859 Part 8, a.k.a. Latin/Hebrew.
-- `ISO_8859_PART9`:
-   ISO/IEC 8859 Part 9, a.k.a. Latin-5 Turkish.
-- `ISO_8859_PART10`:
-   ISO/IEC 8859 Part 10, a.k.a. Latin-6 Nordic.
-- `ISO_8859_PART11`:
-   ISO/IEC 8859 Part 11, a.k.a. Latin/Thai.
-- `ISO_8859_PART13`:
-   ISO/IEC 8859 Part 13, a.k.a. Latin-7 Baltic Rim.
-- `ISO_8859_PART14`:
-   ISO/IEC 8859 Part 14, a.k.a. Latin-8 Celtic.
-- `ISO_8859_PART15`:
-   ISO/IEC 8859 Part 15, a.k.a. Latin-9.
-- `ISO_8859_PART16`:
-   ISO/IEC 8859 Part 16, a.k.a. Latin-10 South-Eastern European.
-- `CP_437`:
-   CP437 (DOS Latin US).
-- `CP_1250`:
-   Windows-1250 (Eastern European).
-- `CP_1251`:
-   Windows-1251 (Cyrillic).
-- `CP_1252`:
-   Windows-1252 (Western European).
-- `CP_1256`:
-   Windows-1256 (Arabic).
-- `SHIFT_JIS`:
-   Shift JIS (Japanese).
-- `BIG_5`:
-   Big5 (Traditional Chinese).
-- `GB_2312`:
-   GB2312 (Simplified Chinese).
-- `GB_18030`:
-   GB18030 (Simplified Chinese).
-- `EUC_JP`:
-   EUC-JP (Japanese).
-- `EUC_KR`:
-   EUC-KR (Korean).
-- `UTF_16_BE`:
-   UTF16BE (UTF-16 Big Endian), a.k.a. UnicodeBig.
-- `UTF_8`:
-   UTF8 (UTF-8).
-- `UTF_16_LE`:
-   UTF16LE (UTF-16 Little Endian).
-- `UTF_32_BE`:
-   UTF32BE (UTF-32 Big Endian).
-- `UTF_32_LE`:
-   UTF32LE (UTF-32 Little Endian).
-- `BINARY`:
-   Binary data.
-*/
-export type CharacterEncoding = "UNKNOWN" | "ASCII" | "ISO_8859_PART1" | "ISO_8859_PART2" | "ISO_8859_PART3" | "ISO_8859_PART4" | "ISO_8859_PART5" | "ISO_8859_PART6" | "ISO_8859_PART7" | "ISO_8859_PART8" | "ISO_8859_PART9" | "ISO_8859_PART10" | "ISO_8859_PART11" | "ISO_8859_PART13" | "ISO_8859_PART14" | "ISO_8859_PART15" | "ISO_8859_PART16" | "CP_437" | "CP_1250" | "CP_1251" | "CP_1252" | "CP_1256" | "SHIFT_JIS" | "BIG_5" | "GB_2312" | "GB_18030" | "EUC_JP" | "EUC_KR" | "UTF_16_BE" | "UTF_8" | "UTF_16_LE" | "UTF_32_BE" | "UTF_32_LE" | "BINARY";
-export declare const CharacterEncodingValues: CharacterEncoding[];
-/**
-A character encoding for a given range of bytes.
-*/
-export declare class RangeEncoding extends PartiallyConstructible {
-    /**
-    Start index of the range.
-    */
-    readonly start: number;
-    /**
-    End index of the range (inclusive).
-    */
-    readonly end: number;
-    /**
-    Character encoding for the given range.
-    */
-    readonly encoding: CharacterEncoding;
-    /** @param source {@displayType `DeepPartial<RangeEncoding>`} */
-    constructor(source?: DeepPartial<RangeEncoding>);
-}
-/**
-The structured append mode can be used to split a message across multiple barcodes.
-*/
-export declare class StructuredAppendInfo extends PartiallyConstructible {
-    /**
-    The number of barcodes in the structured append set.
-    */
-    readonly count: number;
-    /**
-    The index of the barcode in the structured append set.
-    */
-    readonly index: number;
-    /**
-    The ID of the structured append set.
-    */
-    readonly id: string;
-    /** @param source {@displayType `DeepPartial<StructuredAppendInfo>`} */
-    constructor(source?: DeepPartial<StructuredAppendInfo>);
-}
-/**
 Enumerates barcode formats.
 
 - `NONE`:

package/@types/core/{compiled → bridge/compiled}/CheckScannerTypes.d.ts

@@ -1,8 +1,7 @@
 import { DeepPartial, PartiallyConstructible } from "./utils";
 import { DocumentDetectionResult } from "./DocumentScannerTypes";
 import { GenericDocument } from "./GenericDocument";
-import { Image } from "./bridge/image";
-import { ProcessingMode } from "./CommonTypes";
+import { RawImage } from "./utils";
 /**
 Check document detection and extraction mode.
 
@@ -47,7 +46,7 @@ export declare class CheckScanningResult extends PartiallyConstructible {
     /**
     Crop of the check if documentDetectionMode is set to DETECT_AND_CROP_DOCUMENT. Will be non-empty, only if check recognition succeeded.
     */
-    readonly croppedImage: Image | null;
+    readonly croppedImage: RawImage | null;
     /** @param source {@displayType `DeepPartial<CheckScanningResult>`} */
     constructor(source?: DeepPartial<CheckScanningResult>);
 }
@@ -63,14 +62,6 @@ export declare class CheckScannerConfiguration extends PartiallyConstructible {
     @defaultValue "DISABLED";
     */
     documentDetectionMode: CheckDocumentDetectionMode;
-    /**
-    Scanners typically can produce better results from a single image if they are allowed to spend a longer time analyzing it.
-    
-    On the other hand, scanners can produce even better results if they can analyze multiple images of the same subject and cross-check and combine the results.
-    The processing mode tells the scanner whether to optimize for single or multiple images of a subject.
-    @defaultValue "AUTO";
-    */
-    processingMode: ProcessingMode;
     /** @param source {@displayType `DeepPartial<CheckScannerConfiguration>`} */
     constructor(source?: DeepPartial<CheckScannerConfiguration>);
 }

package/@types/core/{compiled → bridge/compiled}/CreditCardTypes.d.ts

@@ -2,7 +2,6 @@ import { DeepPartial, PartiallyConstructible } from "./utils";
 import { DocumentDetectionStatus } from "./DocumentScannerTypes";
 import { GenericDocument } from "./GenericDocument";
 import { Point } from "./utils";
-import { ProcessingMode } from "./CommonTypes";
 import { ResultAccumulationConfiguration } from "./FrameAccumulationTypes";
 /**
 The status of the scanning process.
@@ -44,6 +43,17 @@ export declare class CreditCardScanningResult extends PartiallyConstructible {
     constructor(source?: DeepPartial<CreditCardScanningResult>);
 }
 /**
+The scanning mode.
+
+- `LIVE`:
+   The scanner will merge all information from multiple frames to provide the best possible result.
+   Use this mode when the input is a video or camera stream.
+- `SINGLE_SHOT`:
+   The scanner will only use the current frame and will spend additional time to ensure the best possible result. Use this mode when scanning single images, e.g. imported from the gallery.
+*/
+export type CreditCardScanningMode = "LIVE" | "SINGLE_SHOT";
+export declare const CreditCardScanningModeValues: CreditCardScanningMode[];
+/**
 Configuration for the credit card scanner.
 */
 export declare class CreditCardScannerConfiguration extends PartiallyConstructible {
@@ -54,6 +64,11 @@ export declare class CreditCardScannerConfiguration extends PartiallyConstructib
     */
     useDocumentDetector: boolean;
     /**
+    The scanning mode.
+    @defaultValue "LIVE";
+    */
+    scanningMode: CreditCardScanningMode;
+    /**
     Whether the expiry date is required for a successful scan.
     @defaultValue true;
     */
@@ -73,14 +88,6 @@ export declare class CreditCardScannerConfiguration extends PartiallyConstructib
     @defaultValue false;
     */
     returnCreditCardImage: boolean;
-    /**
-    Scanners typically can produce better results from a single image if they are allowed to spend a longer time analyzing it.
-    
-    On the other hand, scanners can produce even better results if they can analyze multiple images of the same subject and cross-check and combine the results.
-    The processing mode tells the scanner whether to optimize for single or multiple images of a subject.
-    @defaultValue "AUTO";
-    */
-    processingMode: ProcessingMode;
     /** @param source {@displayType `DeepPartial<CreditCardScannerConfiguration>`} */
     constructor(source?: DeepPartial<CreditCardScannerConfiguration>);
 }

package/@types/core/{compiled → bridge/compiled}/DocumentDataExtractorConfigurationTypes.d.ts

@@ -3,7 +3,7 @@ import { MrzDocumentType } from "./MrzTypes";
 /**
 Base class for all generic document configuration elements.
 */
-export type DocumentDataExtractorConfigurationElement = DateValidationConfiguration | DeAddressParserConfiguration | EuropeanHealthInsuranceCardConfiguration | MrzFallbackConfiguration | AutoFocusConfiguration | GlareDetectionConfiguration | DocumentDataExtractorCommonConfiguration;
+export type DocumentDataExtractorConfigurationElement = DateValidationConfiguration | EuropeanHealthInsuranceCardConfiguration | MrzFallbackConfiguration | DocumentDataExtractorCommonConfiguration;
 /** @internal */
 export declare namespace DocumentDataExtractorConfigurationElement {
     /** @internal */
@@ -36,26 +36,6 @@ export declare class DateValidationConfiguration extends PartiallyConstructible
     constructor(source?: DeepPartial<DateValidationConfiguration>);
 }
 /**
-German Address Field validation configuration.
-This configuration does not enable the scanning of any document types by itself.
-Add to recognizer configuration to require German Address validation checks for specific document types.
-*/
-export declare class DeAddressParserConfiguration extends PartiallyConstructible {
-    readonly _type: "DeAddressParserConfiguration";
-    /**
-    List of generic document formats for which German Address validation has to be applied.
-    @defaultValue [];
-    */
-    documentTypes: string[];
-    /**
-    binary file with address database.
-    @defaultValue "";
-    */
-    binaryFileAddressDatabase: string;
-    /** @param source {@displayType `DeepPartial<DeAddressParserConfiguration>`} */
-    constructor(source?: DeepPartial<DeAddressParserConfiguration>);
-}
-/**
 European Health Insurance Card (EHIC) issuing country.
 
 - `AUSTRIA`:
@@ -154,43 +134,6 @@ export declare class MrzFallbackConfiguration extends PartiallyConstructible {
     constructor(source?: DeepPartial<MrzFallbackConfiguration>);
 }
 /**
-Auto-focus configuration.
-The recognizer will ignore frames that are not focused. This option is enabled by default.
-This configuration has no effect in SINGLE_SHOT mode.
-*/
-export declare class AutoFocusConfiguration extends PartiallyConstructible {
-    readonly _type: "AutoFocusConfiguration";
-    /**
-    Sensitivity threshold for detecting that autofocus is in progress.
-    The value should be in the range [0.0, 1.0].
-    The lower the value, the more frames might be discarded as not focused.
-    The higher the value, the earlier the focus might be considered as focused.
-    If set to 0.0, the feature is disabled.
-    @defaultValue 0.02;
-    */
-    sensitivityThreshold: number;
-    /** @param source {@displayType `DeepPartial<AutoFocusConfiguration>`} */
-    constructor(source?: DeepPartial<AutoFocusConfiguration>);
-}
-/**
-Glare detection configuration.
-The recognizer will detect whether fields are obstructed by glare. This feature is enabled by default.
-This configuration has no effect in SINGLE_SHOT mode.
-*/
-export declare class GlareDetectionConfiguration extends PartiallyConstructible {
-    readonly _type: "GlareDetectionConfiguration";
-    /**
-    Glare detection threshold.
-    The value should be in the range [0.0, 1.0].
-    Determines how much glare is acceptable relative to the text size. So 0.5 means that the glare can be up to 50% of the text size.
-    If set to 0.0, the feature is disabled.
-    @defaultValue 0.5;
-    */
-    glareDetectionThreshold: number;
-    /** @param source {@displayType `DeepPartial<GlareDetectionConfiguration>`} */
-    constructor(source?: DeepPartial<GlareDetectionConfiguration>);
-}
-/**
 Convenience configuration element for enabling the scanning of multiple document types with a common configuration.
 Add to extractor configuration to enable the scanning of multiple document types.
 */

package/@types/core/bridge/compiled/DocumentDataExtractorTypes.d.ts

@@ -0,0 +1,95 @@
+import { DeepPartial, PartiallyConstructible } from "./utils";
+import { DocumentDataExtractorConfigurationElement } from "./DocumentDataExtractorConfigurationTypes";
+import { DocumentDetectionResult } from "./DocumentScannerTypes";
+import { GenericDocument } from "./GenericDocument";
+import { RawImage } from "./utils";
+import { ResultAccumulationConfiguration } from "./FrameAccumulationTypes";
+/**
+The status of the extraction process.
+
+- `SUCCESS`:
+   The document was extracted successfully.
+- `ERROR_NOTHING_FOUND`:
+   No document was detected.
+- `ERROR_BAD_CROP`:
+   A document was detected, but it was at an angle/distance that was too large.
+- `ERROR_UNKNOWN_DOCUMENT`:
+   A document was detected, but it was not extracted as a supported document.
+- `ERROR_UNACCEPTABLE_DOCUMENT`:
+   A document was detected as a supported document, but it was not part of the accepted documents.
+- `INCOMPLETE_VALIDATION`:
+   All fields were extracted, but some of them failed validation.
+*/
+export type DocumentDataExtractionStatus = "SUCCESS" | "ERROR_NOTHING_FOUND" | "ERROR_BAD_CROP" | "ERROR_UNKNOWN_DOCUMENT" | "ERROR_UNACCEPTABLE_DOCUMENT" | "INCOMPLETE_VALIDATION";
+export declare const DocumentDataExtractionStatusValues: DocumentDataExtractionStatus[];
+/**
+Contains the result of running the generic document extractor.
+*/
+export declare class DocumentDataExtractionResult extends PartiallyConstructible {
+    /**
+    The status of the extraction process
+    */
+    readonly status: DocumentDataExtractionStatus;
+    /**
+    The extracted document
+    */
+    readonly document: GenericDocument | null;
+    /**
+    Result of the document detection in the input image.
+    */
+    readonly documentDetectionResult: DocumentDetectionResult;
+    /**
+    Crop of the document if it was detected.
+    */
+    readonly croppedImage: RawImage | null;
+    /** @param source {@displayType `DeepPartial<DocumentDataExtractionResult>`} */
+    constructor(source?: DeepPartial<DocumentDataExtractionResult>);
+}
+/**
+The extraction mode.
+
+- `LIVE`:
+   The extractor will attempt to accumulate results over multiple frames.
+- `SINGLE_SHOT`:
+   The extractor will only use the current frame and will spend additional time to ensure the best possible result.
+*/
+export type DocumentDataExtractionMode = "LIVE" | "SINGLE_SHOT";
+export declare const DocumentDataExtractionModeValues: DocumentDataExtractionMode[];
+/**
+Parameters for the extraction process.
+*/
+export declare class DocumentDataFrameExtractionParameters extends PartiallyConstructible {
+    /**
+    The extraction mode.
+    @defaultValue "LIVE";
+    */
+    mode: DocumentDataExtractionMode;
+    /** @param source {@displayType `DeepPartial<DocumentDataFrameExtractionParameters>`} */
+    constructor(source?: DeepPartial<DocumentDataFrameExtractionParameters>);
+}
+/**
+Configuration for the document data extractor.
+*/
+export declare class DocumentDataExtractorConfiguration extends PartiallyConstructible {
+    /**
+    Configuration for how to accumulate results.
+    @defaultValue new ResultAccumulationConfiguration({});
+    */
+    resultAccumulationConfig: ResultAccumulationConfiguration;
+    /**
+    Normalized names of the fields to exclude from the result.
+    @defaultValue [];
+    */
+    fieldExcludeList: string[];
+    /**
+    List of configuration elements for the document data extractor
+    */
+    configurations: DocumentDataExtractorConfigurationElement[];
+    /**
+    If true, crops of the detected documents and fields will be returned in the result.
+    @defaultValue false;
+    */
+    returnCrops: boolean;
+    /** @param source {@displayType `DeepPartial<DocumentDataExtractorConfiguration>`} */
+    constructor(source?: DeepPartial<DocumentDataExtractorConfiguration>);
+}

package/@types/core/{compiled → bridge/compiled}/DocumentQualityAnalyzerTypes.d.ts

@@ -1,5 +1,5 @@
 import { DeepPartial, PartiallyConstructible } from "./utils";
-import { Image } from "./bridge/image";
+import { RawImage } from "./utils";
 /**
 Result of document quality analysis.
 
@@ -137,7 +137,7 @@ export declare class DocumentQualityAnalyzerResult extends PartiallyConstructibl
     Black marks areas of no detected text. Colors represent the quality of detected text,
     with red meaning the lowest quality and yellow and green meaning progressively higher quality.
     */
-    readonly qualityHeatmap: Image | null;
+    readonly qualityHeatmap: RawImage | null;
     /** @param source {@displayType `DeepPartial<DocumentQualityAnalyzerResult>`} */
     constructor(source?: DeepPartial<DocumentQualityAnalyzerResult>);
 }

package/@types/core/{compiled → bridge/compiled}/DocumentScannerTypes.d.ts

@@ -1,10 +1,8 @@
 import { AspectRatio } from "./Geometry";
 import { DeepPartial, PartiallyConstructible } from "./utils";
-import { Image } from "./bridge/image";
 import { LineSegmentFloat } from "./Geometry";
 import { LineSegmentInt } from "./Geometry";
 import { Point } from "./utils";
-import { ProcessingMode } from "./CommonTypes";
 /**
 Engines for document scanning.
 
@@ -78,11 +76,6 @@ export declare class DocumentScannerConfiguration extends PartiallyConstructible
     */
     engineMode: DocumentScannerEngineMode;
     /**
-    In live mode, the document scanner will return only the best document contour. In single-shot mode it will return additional document contours, suitable for use in the cropping screen.
-    @defaultValue "AUTO";
-    */
-    processingMode: ProcessingMode;
-    /**
     Initial parameters for the document scanner.
     @defaultValue new DocumentScannerParameters({});
     */
@@ -212,18 +205,3 @@ export declare class DocumentDetectionResult extends PartiallyConstructible {
     /** @param source {@displayType `DeepPartial<DocumentDetectionResult>`} */
     constructor(source?: DeepPartial<DocumentDetectionResult>);
 }
-/**
-Result of the document detection followed by cropping of the found document.
-*/
-export declare class DocumentScanningResult extends PartiallyConstructible {
-    /**
-    Result of the document contour detection
-    */
-    readonly detectionResult: DocumentDetectionResult;
-    /**
-    Cropped document image
-    */
-    readonly croppedImage: Image | null;
-    /** @param source {@displayType `DeepPartial<DocumentScanningResult>`} */
-    constructor(source?: DeepPartial<DocumentScanningResult>);
-}