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

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

@@ -0,0 +1,183 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { DocumentType as GenericDocumentTypesDocumentType } from "./GenericDocumentTypes";
+import { DocumentType as MRZTypesDocumentType } from "./MRZTypes";
+/**
+Base class for all generic document configurations.
+*/
+export type GDRConfig = DateValidationConfig | EuropeanHealthInsuranceCardConfig | MRZFallbackConfig | GDRGroupConfig;
+/** @internal */
+export declare namespace GDRConfig {
+    /** @internal */
+    function From(source: {
+        [key: string]: any;
+    }): GDRConfig;
+}
+/**
+Date validation configuration.
+This configuration does not enable the scanning of any document types by itself.
+Add to recognizer configuration to require date validation checks for specific document types.
+
+*/
+export declare class DateValidationConfig extends PartiallyConstructible {
+    readonly _type: "DateValidationConfig";
+    /**
+    Minimum year of birth
+    @defaultValue 0;
+    */
+    readonly minBirthYear: number;
+    /**
+    Maximum year of birth
+    @defaultValue 2999;
+    */
+    readonly maxBirthYear: number;
+    /**
+    Minimum card expiration year
+    @defaultValue 0;
+    */
+    readonly minExpirationYear: number;
+    /**
+    Maximum card expiration year
+    @defaultValue 2999;
+    */
+    readonly maxExpirationYear: number;
+    /**
+    List of generic document formats for which date validation has to be applied.
+    @defaultValue [];
+    */
+    readonly documentTypes: GenericDocumentTypesDocumentType[];
+    /** @param source {@displayType `DeepPartial<DateValidationConfig>`} */
+    constructor(source?: DeepPartial<DateValidationConfig>);
+}
+/**
+Health insurance card issuing country
+
+- `AUSTRIA`:
+   Austria (Validation on the personal identification number is performed as described in "site:www.sozialversicherung.at Was ist die Versicherungsnummer?")
+- `BELGIUM`:
+   Belgium
+- `BULGARIA`:
+   Bulgaria
+- `CROATIA`:
+   Croatia
+- `CYPRUS`:
+   Cyprus
+- `CZECH_REPUBLIC`:
+   Czech Republic
+- `DENMARK`:
+   Denmark
+- `ESTONIA`:
+   Estonia
+- `FINLAND`:
+   Finland
+- `FRANCE`:
+   France
+- `GERMANY`:
+   Germany (Validation performed according to "Spezifikation für Musterkarten und Testkarten (eGK, HBA, SMC), Anhang A" and "GS1 Struktur der Kenn-Nummer (ICCSN) der elektronischen Gesundheitskarte")
+- `GREECE`:
+   Greece
+- `HUNGARY`:
+   Hungary
+- `IRELAND`:
+   Ireland
+- `ITALY`:
+   Italy
+- `LATVIA`:
+   Latvia
+- `LITHUANIA`:
+   Lithuania
+- `LUXEMBOURG`:
+   Luxembourg
+- `MALTA`:
+   Malta
+- `NETHERLANDS`:
+   Netherlands
+- `POLAND`:
+   Poland
+- `PORTUGAL`:
+   Portugal
+- `ROMANIA`:
+   Romania
+- `SLOVAKIA`:
+   Slovakia
+- `SLOVENIA`:
+   Slovenia
+- `SPAIN`:
+   Spain
+- `SWEDEN`:
+   Sweden
+- `SWITZERLAND`:
+   Switzerland
+*/
+export type EHICIssuingCountry = "AUSTRIA" | "BELGIUM" | "BULGARIA" | "CROATIA" | "CYPRUS" | "CZECH_REPUBLIC" | "DENMARK" | "ESTONIA" | "FINLAND" | "FRANCE" | "GERMANY" | "GREECE" | "HUNGARY" | "IRELAND" | "ITALY" | "LATVIA" | "LITHUANIA" | "LUXEMBOURG" | "MALTA" | "NETHERLANDS" | "POLAND" | "PORTUGAL" | "ROMANIA" | "SLOVAKIA" | "SLOVENIA" | "SPAIN" | "SWEDEN" | "SWITZERLAND";
+/**
+EHIC configuration. Add to recognizer configuration to scan EHIC.
+*/
+export declare class EuropeanHealthInsuranceCardConfig extends PartiallyConstructible {
+    readonly _type: "EuropeanHealthInsuranceCardConfig";
+    /**
+    Minimum year of birth
+    @defaultValue 0;
+    */
+    readonly minBirthYear: number;
+    /**
+    Maximum year of birth
+    @defaultValue 2999;
+    */
+    readonly maxBirthYear: number;
+    /**
+    Minimum card expiration year
+    @defaultValue 0;
+    */
+    readonly minExpirationYear: number;
+    /**
+    Maximum card expiration year
+    @defaultValue 2999;
+    */
+    readonly maxExpirationYear: number;
+    /**
+    If an expected country is selected, validation rules for the given country are used, a
+    and if the expected country cannot be inferred or the inferred country doesn't  match the given country,
+    the result of recognize() will be IncompleteValidation.
+    @defaultValue null;
+    */
+    readonly expectedCountry: EHICIssuingCountry | null;
+    /** @param source {@displayType `DeepPartial<EuropeanHealthInsuranceCardConfig>`} */
+    constructor(source?: DeepPartial<EuropeanHealthInsuranceCardConfig>);
+}
+/**
+MRZ fallback configuration.
+This configuration does not enable the scanning of any document types by itself.
+Add to recognizer configuration to enable recognizing the MRZ only, specifically for documents that are otherwise not supported.
+Note that this may enable scanning of documents that were not enabled through the accepted document types.
+
+*/
+export declare class MRZFallbackConfig extends PartiallyConstructible {
+    readonly _type: "MRZFallbackConfig";
+    /**
+    List of ISO 3166-1 alpha-3 country codes for which MRZ fallback is enabled. (e.g. "DEU" for Germany)
+    @defaultValue [];
+    */
+    readonly acceptedCountries: string[];
+    /**
+    List of MRZ document formats for which MRZ fallback is enabled.
+    @defaultValue [];
+    */
+    readonly acceptedMRZTypes: MRZTypesDocumentType[];
+    /** @param source {@displayType `DeepPartial<MRZFallbackConfig>`} */
+    constructor(source?: DeepPartial<MRZFallbackConfig>);
+}
+/**
+Convenience configuration for enabling the scanning of multiple generic document types with a common configuration.
+Add to recognizer configuration to enable the scanning of multiple generic documents.
+
+*/
+export declare class GDRGroupConfig extends PartiallyConstructible {
+    readonly _type: "GDRGroupConfig";
+    /**
+    List of generic document formats to scan. By default, the list is empty.
+    @defaultValue [];
+    */
+    readonly acceptedDocumentTypes: GenericDocumentTypesDocumentType[];
+    /** @param source {@displayType `DeepPartial<GDRGroupConfig>`} */
+    constructor(source?: DeepPartial<GDRGroupConfig>);
+}

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

@@ -0,0 +1,105 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { GDRConfig } from "./GenericDocumentRecognizerConfigs";
+import { GenericDocument } from "./GenericDocument";
+import { Point } from "../common";
+/**
+The status of the recognition process
+
+- `SUCCESS`:
+   The document was recognized 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 recognized 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 recognized, but some of them failed validation
+*/
+export type RecognitionStatus = "SUCCESS" | "ERROR_NOTHING_FOUND" | "ERROR_BAD_CROP" | "ERROR_UNKNOWN_DOCUMENT" | "ERROR_UNACCEPTABLE_DOCUMENT" | "INCOMPLETE_VALIDATION";
+/**
+Contains the result of running the generic document recognizer
+*/
+export declare class RecognitionResult extends PartiallyConstructible {
+    /**
+    The status of the recognition process
+    */
+    readonly status: RecognitionStatus;
+    /**
+    The recognized document
+    */
+    readonly document: GenericDocument | null;
+    /**
+    Coordinates of the detected document in the input image (clockwise from top-left)
+    */
+    readonly quad: Point[] | null;
+    /** @param source {@displayType `DeepPartial<RecognitionResult>`} */
+    constructor(source?: DeepPartial<RecognitionResult>);
+}
+/**
+The recognition mode
+
+- `LIVE`:
+   The recognizer will attempt to accumulate results over multiple frames.
+- `SINGLE_SHOT`:
+   The recognizer will only use the current frame and will spend additional time to ensure the best possible result.
+*/
+export type RecognitionMode = "LIVE" | "SINGLE_SHOT";
+/**
+Parameters for the recognition process
+*/
+export declare class RecognitionParameters extends PartiallyConstructible {
+    /**
+    The recognition mode
+    @defaultValue "LIVE";
+    */
+    mode: RecognitionMode;
+    /** @param source {@displayType `DeepPartial<RecognitionParameters>`} */
+    constructor(source?: DeepPartial<RecognitionParameters>);
+}
+/**
+Configuration for how to accumulate results
+*/
+export declare class ResultAccumulationConfig extends PartiallyConstructible {
+    /**
+    Number of identical results required to consider a field confirmed
+    @defaultValue 3;
+    */
+    minConfirmations: number;
+    /**
+    Minimum confidence required to consider a field confirmed
+    @defaultValue 0.8;
+    */
+    minConfidenceForStableField: number;
+    /**
+    Will auto-clear the cache if this number of frames have been a different document type or empty
+    @defaultValue 4;
+    */
+    autoClearThreshold: number;
+    /** @param source {@displayType `DeepPartial<ResultAccumulationConfig>`} */
+    constructor(source?: DeepPartial<ResultAccumulationConfig>);
+}
+/**
+Configuration for the generic document recognizer
+*/
+export declare class GenericDocumentRecognizerParameters extends PartiallyConstructible {
+    /**
+    Configuration for how to accumulate results
+    @defaultValue new ResultAccumulationConfig({});
+    */
+    resultAccumulationConfig: ResultAccumulationConfig;
+    /**
+    Normalized names of the fields to exclude from the result
+    @defaultValue [];
+    */
+    fieldExcludeList: string[];
+    /**
+    Options for generic document decoding
+    @defaultValue [new GDRGroupConfig({})];
+    */
+    configurations: GDRConfig[];
+    /** @param source {@displayType `DeepPartial<GenericDocumentRecognizerParameters>`} */
+    constructor(source?: DeepPartial<GenericDocumentRecognizerParameters>);
+}

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

@@ -0,0 +1,38 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+/**
+Enumerates generic document formats.
+
+- `DeIdCardFront`:
+   DeIdCardFront
+- `DeIdCardBack`:
+   DeIdCardBack
+- `DePassport`:
+   DePassport
+- `DeDriverLicenseFront`:
+   DeDriverLicenseFront
+- `DeDriverLicenseBack`:
+   DeDriverLicenseBack
+- `DeResidencePermitFront`:
+   DeResidencePermitFront
+- `DeResidencePermitBack`:
+   DeResidencePermitBack
+- `EuropeanHealthInsuranceCard`:
+   EuropeanHealthInsuranceCard
+- `DeHealthInsuranceCardFront`:
+   DeHealthInsuranceCardFront
+*/
+export type DocumentType = "DeIdCardFront" | "DeIdCardBack" | "DePassport" | "DeDriverLicenseFront" | "DeDriverLicenseBack" | "DeResidencePermitFront" | "DeResidencePermitBack" | "EuropeanHealthInsuranceCard" | "DeHealthInsuranceCardFront";
+/**
+Lists of generic document types to decode
+*/
+export declare class DocumentTypes extends PartiallyConstructible {
+    /** @param source {@displayType `DeepPartial<DocumentTypes>`} */
+    constructor(source?: DeepPartial<DocumentTypes>);
+}
+export declare namespace DocumentTypes {
+    /**
+    List of all generic document types
+    @defaultValue ["DeIdCardFront", "DeIdCardBack", "DePassport", "DeDriverLicenseFront", "DeDriverLicenseBack", "DeResidencePermitFront", "DeResidencePermitBack", "EuropeanHealthInsuranceCard", "DeHealthInsuranceCardFront"];
+    */
+    const all: DocumentType[];
+}

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

@@ -0,0 +1,165 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { Rectangle } from "../common";
+/**
+Structure containing recognized word text and bounds
+*/
+export declare class WordBox extends PartiallyConstructible {
+    /**
+    Recognized word text
+    */
+    readonly text: string;
+    /**
+    Bounding rectangle of the recognized word
+    */
+    readonly boundingRect: Rectangle;
+    /**
+    Confidence of the recognition
+    @defaultValue 0.0;
+    */
+    readonly recognitionConfidence: number;
+    /** @param source {@displayType `DeepPartial<WordBox>`} */
+    constructor(source?: DeepPartial<WordBox>);
+}
+/**
+Structure containing recognized symbol text and bounds
+*/
+export declare class SymbolBox extends PartiallyConstructible {
+    /**
+    Recognized symbol text
+    */
+    readonly symbol: string;
+    /**
+    Bounding rectangle of the recognized symbol
+    */
+    readonly boundingRect: Rectangle;
+    /**
+    Confidence of the recognition
+    */
+    readonly recognitionConfidence: number;
+    /** @param source {@displayType `DeepPartial<SymbolBox>`} */
+    constructor(source?: DeepPartial<SymbolBox>);
+}
+/**
+The result of the text line recognition
+*/
+export declare class ScannerResult extends PartiallyConstructible {
+    /**
+    Raw recognized string
+    */
+    readonly rawText: string;
+    /**
+    Boxes for each recognized word
+    */
+    readonly wordBoxes: WordBox[];
+    /**
+    Boxes for each recognized symbol
+    */
+    readonly symbolBoxes: SymbolBox[];
+    /**
+    Confidence of the recognition
+    @defaultValue 0.0;
+    */
+    readonly confidence: number;
+    /**
+    Whether the validation was successful
+    @defaultValue false;
+    */
+    readonly validationSuccessful: boolean;
+    /** @param source {@displayType `DeepPartial<ScannerResult>`} */
+    constructor(source?: DeepPartial<ScannerResult>);
+}
+/**
+Preset for the validation
+
+- `VEHICLE_IDENTIFICATION_NUMBER`:
+   Validation rules for vehicle identification numbers
+*/
+export type ValidatorPreset = "VEHICLE_IDENTIFICATION_NUMBER";
+/**
+Base class for content validators
+*/
+export type ContentValidator = DefaultContentValidator | PresetContentValidator | PatternContentValidator;
+/** @internal */
+export declare namespace ContentValidator {
+    /** @internal */
+    function From(source: {
+        [key: string]: any;
+    }): ContentValidator;
+}
+/**
+Default content validator. Accepts only non-empty strings.
+*/
+export declare class DefaultContentValidator extends PartiallyConstructible {
+    readonly _type: "DefaultContentValidator";
+    /**
+    OCR whitelist. Empty string means no restriction.
+    @defaultValue "";
+    */
+    allowedCharacters: string;
+    /** @param source {@displayType `DeepPartial<DefaultContentValidator>`} */
+    constructor(source?: DeepPartial<DefaultContentValidator>);
+}
+/**
+Preset content validator
+*/
+export declare class PresetContentValidator extends PartiallyConstructible {
+    readonly _type: "PresetContentValidator";
+    /**
+    Validator preset
+    */
+    preset: ValidatorPreset;
+    /** @param source {@displayType `DeepPartial<PresetContentValidator>`} */
+    constructor(source?: DeepPartial<PresetContentValidator>);
+}
+/**
+Pattern content validator
+*/
+export declare class PatternContentValidator extends PartiallyConstructible {
+    readonly _type: "PatternContentValidator";
+    /**
+    OCR whitelist. Empty string means no restriction.
+    @defaultValue "";
+    */
+    allowedCharacters: string;
+    /**
+    Wildcard validation pattern.
+      ? - any character
+      # - any digit
+      all other characters represent themselves
+    */
+    pattern: string;
+    /**
+    Whether the pattern should match the whole string or just a substring
+    @defaultValue false;
+    */
+    matchSubstring: boolean;
+    /** @param source {@displayType `DeepPartial<PatternContentValidator>`} */
+    constructor(source?: DeepPartial<PatternContentValidator>);
+}
+/**
+Configuration for the generic text line scanner
+*/
+export declare class ScannerConfiguration extends PartiallyConstructible {
+    /**
+    Maximum image side (height or width) for OCR process. 0 - do not rescale.
+    @defaultValue 0;
+    */
+    ocrResolutionLimit: number;
+    /**
+    Maximum number of accumulated frames to inspect before actual result is returned
+    @defaultValue 3;
+    */
+    maximumNumberOfAccumulatedFrames: number;
+    /**
+    Minimum number of accumulated frames that have equal result
+    @defaultValue 2;
+    */
+    minimumNumberOfRequiredFramesWithEqualRecognitionResult: number;
+    /**
+    Content validator
+    @defaultValue new DefaultContentValidator({});
+    */
+    validator: ContentValidator;
+    /** @param source {@displayType `DeepPartial<ScannerConfiguration>`} */
+    constructor(source?: DeepPartial<ScannerConfiguration>);
+}

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

@@ -0,0 +1,49 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { Point } from "../common";
+/**
+Represents a line segment in 2D space
+*/
+export declare class LineSegmentInt extends PartiallyConstructible {
+    /**
+    Start point of the segment
+    */
+    readonly start: Point;
+    /**
+    End point of the segment
+    */
+    readonly end: Point;
+    /** @param source {@displayType `DeepPartial<LineSegmentInt>`} */
+    constructor(source?: DeepPartial<LineSegmentInt>);
+}
+/**
+Represents a line segment in 2D space
+*/
+export declare class LineSegmentFloat extends PartiallyConstructible {
+    /**
+    Start point of the segment
+    */
+    readonly start: Point;
+    /**
+    End point of the segment
+    */
+    readonly end: Point;
+    /** @param source {@displayType `DeepPartial<LineSegmentFloat>`} */
+    constructor(source?: DeepPartial<LineSegmentFloat>);
+}
+/**
+Aspect ratio is the ratio of the width to the height of an image or screen.
+*/
+export declare class AspectRatio extends PartiallyConstructible {
+    /**
+    Width component of the aspect ratio.
+    @defaultValue 1.0;
+    */
+    readonly width: number;
+    /**
+    Height component of the aspect ratio.
+    @defaultValue 1.0;
+    */
+    readonly height: number;
+    /** @param source {@displayType `DeepPartial<AspectRatio>`} */
+    constructor(source?: DeepPartial<AspectRatio>);
+}

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

@@ -0,0 +1,13 @@
+/**
+Image rotation.
+
+- `ROTATION_NONE`:
+   No rotation.
+- `ROTATION_90_CLOCKWISE`:
+   90 degrees clockwise rotation.
+- `ROTATION_180`:
+   180 degrees rotation.
+- `ROTATION_90_COUNTERCLOCKWISE`:
+   90 degrees counterclockwise rotation.
+*/
+export type ImageRotation = "ROTATION_NONE" | "ROTATION_90_CLOCKWISE" | "ROTATION_180" | "ROTATION_90_COUNTERCLOCKWISE";

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

@@ -0,0 +1,67 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { RawImage } from "../common";
+/**
+Type of the scanner internally to scan the license plate
+
+- `CLASSIC`:
+   Classic scanning strategy
+- `ML`:
+   ML-based scanning strategy
+*/
+export type ScannerStrategy = "CLASSIC" | "ML";
+/**
+Configuration for the license plate scanner
+*/
+export declare class ScannerConfiguration extends PartiallyConstructible {
+    /**
+    Maximum number of accumulated frames to inspect before actual result is returned
+    @defaultValue 3;
+    */
+    maximumNumberOfAccumulatedFrames: number;
+    /**
+    Minimum number of accumulated frames that have equal result
+    @defaultValue 2;
+    */
+    minimumNumberOfRequiredFramesWithEqualScanningResult: number;
+    /**
+    Strategy to use for scanning
+    @defaultValue "ML";
+    */
+    scannerStrategy: ScannerStrategy;
+    /** @param source {@displayType `DeepPartial<ScannerConfiguration>`} */
+    constructor(source?: DeepPartial<ScannerConfiguration>);
+}
+/**
+The result of the license plate scanning
+*/
+export declare class ScannerResult extends PartiallyConstructible {
+    /**
+    Country code
+    */
+    readonly countryCode: string;
+    /**
+    License plate
+    */
+    readonly licensePlate: string;
+    /**
+    Raw recognized string
+    */
+    readonly rawText: string;
+    /**
+    Recognition confidence
+    @defaultValue 0.0;
+    */
+    readonly confidence: number;
+    /**
+    Text validation result
+    @defaultValue false;
+    */
+    readonly validationSuccessful: boolean;
+    /**
+    The part of the image on which the plate was detected
+    @defaultValue null;
+    */
+    readonly croppedImage: RawImage | null;
+    /** @param source {@displayType `DeepPartial<ScannerResult>`} */
+    constructor(source?: DeepPartial<ScannerResult>);
+}

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

@@ -0,0 +1,52 @@
+import { AccumulatedResultsVerifierConfig } from "./FrameUtilities";
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { GenericDocument } from "./GenericDocument";
+/**
+Type of document containing the MRZ
+
+- `UNKNOWN`:
+   Undefined
+- `CREW_MEMBER_CERTIFICATE`:
+   Crew member certificate
+- `ID_CARD`:
+   ID card
+- `PASSPORT`:
+   Passport
+- `VISA`:
+   Visa card
+- `CH_DRIVING_LICENSE`:
+   Swiss driver license
+*/
+export type DocumentType = "UNKNOWN" | "CREW_MEMBER_CERTIFICATE" | "ID_CARD" | "PASSPORT" | "VISA" | "CH_DRIVING_LICENSE";
+/**
+Container for result of MRZ recognition attempt
+*/
+export declare class RecognitionResult extends PartiallyConstructible {
+    /**
+    Recognition successful
+    @defaultValue false;
+    */
+    readonly recognitionSuccessful: boolean;
+    /**
+    Raw string value of MRZ
+    */
+    readonly rawMRZ: string;
+    /**
+    Generic document containing MRZ data
+    */
+    readonly document: GenericDocument | null;
+    /** @param source {@displayType `DeepPartial<RecognitionResult>`} */
+    constructor(source?: DeepPartial<RecognitionResult>);
+}
+/**
+Configuration for MRZ recognizer
+*/
+export declare class RecognizerConfiguration extends PartiallyConstructible {
+    /**
+    Configure the frame accumulation process
+    @defaultValue new AccumulatedResultsVerifierConfig({});
+    */
+    accumulatedResultsVerifierConfig: AccumulatedResultsVerifierConfig;
+    /** @param source {@displayType `DeepPartial<RecognizerConfiguration>`} */
+    constructor(source?: DeepPartial<RecognizerConfiguration>);
+}