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

package/@types/core/bridge/compiled_schemas_v3/DocumentQualityAnalyzerTypes.d.ts

@@ -0,0 +1,105 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+/**
+Result of document quality analysis.
+
+- `VERY_POOR`:
+   Very poor quality
+- `POOR`:
+   Poor quality
+- `REASONABLE`:
+   Reasonable quality
+- `GOOD`:
+   Good quality
+- `EXCELLENT`:
+   Excellent quality
+*/
+export type Quality = "VERY_POOR" | "POOR" | "REASONABLE" | "GOOD" | "EXCELLENT";
+/**
+Point in the quality-number of symbols space to separate quality levels
+*/
+export declare class QualityThreshold extends PartiallyConstructible {
+    /**
+    Symbol quality
+    */
+    readonly symbolQuality: number;
+    /**
+    Symbol ratio
+    */
+    readonly symbolRatio: number;
+    /** @param source {@displayType `DeepPartial<QualityThreshold>`} */
+    constructor(source?: DeepPartial<QualityThreshold>);
+}
+/**
+Document Quality Analyzer configuration
+*/
+export declare class Config extends PartiallyConstructible {
+    /**
+    Quality thresholds to separate quality levels
+    @defaultValue [new QualityThreshold({
+        "symbolQuality": 0.5,
+        "symbolRatio": 0.5
+    }), new QualityThreshold({
+        "symbolQuality": 0.7,
+        "symbolRatio": 0.3
+    }), new QualityThreshold({
+        "symbolQuality": 0.85,
+        "symbolRatio": 0.3
+    }), new QualityThreshold({
+        "symbolQuality": 0.9,
+        "symbolRatio": 0.1
+    })];
+    */
+    readonly qualityThresholds: QualityThreshold[];
+    /**
+    quality levels
+    @defaultValue ["VERY_POOR", "POOR", "REASONABLE", "GOOD", "EXCELLENT"];
+    */
+    readonly qualityIndices: Quality[];
+    /**
+    Maximum image size in pixels, if image is bigger, it will be resized
+    @defaultValue 2000;
+    */
+    readonly maxImageSize: number;
+    /**
+    if estimated number of symbols is less than this value, return that document is not found
+    @defaultValue 20;
+    */
+    minEstimatedNumberOfSymbolsForDocument: number;
+    /**
+    at least this fraction of the image will be processed, range is from 0 to 1
+    @defaultValue 0.0;
+    */
+    readonly minProcessedFraction: number;
+    /**
+    at most this fraction of the image will be processed, range is from 0 to 1
+    @defaultValue 0.5;
+    */
+    readonly maxProcessedFraction: number;
+    /**
+    If this number of symbols is found and minProcessedFraction of the image is processed, the processing stops
+    @defaultValue 100;
+    */
+    readonly earlyStopIfNSymbolsFound: number;
+    /**
+    Image will be processed in tiles of this size; will be ignored if image is small
+    @defaultValue 300;
+    */
+    readonly tileSize: number;
+    /** @param source {@displayType `DeepPartial<Config>`} */
+    constructor(source?: DeepPartial<Config>);
+}
+/**
+Result of document quality analysis. It can be used to determine, e.g., if a document is good enough to be used for OCR processing.
+*/
+export declare class AnalysisResult extends PartiallyConstructible {
+    /**
+    True if a document was found
+    */
+    readonly documentFound: boolean;
+    /**
+    Quality of the document, if found
+    */
+    readonly quality: Quality | null;
+    /** @param source {@displayType `DeepPartial<AnalysisResult>`} */
+    constructor(source?: DeepPartial<AnalysisResult>);
+}

package/@types/core/bridge/compiled_schemas_v3/EhicTypes.d.ts

@@ -0,0 +1,218 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+/**
+The result of the health insurance card recognition
+*/
+export declare class RecognitionResult extends PartiallyConstructible {
+    /**
+    Health insurance card fields
+    */
+    readonly fields: RecognitionResult.Field[];
+    /**
+    Detection status
+    @defaultValue "FAILED_DETECTION";
+    */
+    readonly status: RecognitionResult.DetectionStatus;
+    /** @param source {@displayType `DeepPartial<RecognitionResult>`} */
+    constructor(source?: DeepPartial<RecognitionResult>);
+}
+export declare namespace RecognitionResult {
+    /**
+    Card detection status
+
+    - `SUCCESS`:
+       Detection successful. The fields array is filled with all of the extracted data. All validatable fields have passed validation.
+    - `FAILED_DETECTION`:
+       No document found or the document doesn't look like the back of an EHIC.
+    - `INCOMPLETE_VALIDATION`:
+       A potential EHIC was found but one or more fields failed validation.
+    */
+    type DetectionStatus = "SUCCESS" | "FAILED_DETECTION" | "INCOMPLETE_VALIDATION";
+    /**
+    Health insurance card field
+    */
+    class Field extends PartiallyConstructible {
+        /**
+        Health insurance card field type
+        */
+        readonly type: RecognitionResult.Field.FieldType;
+        /**
+        Recognized value
+        */
+        readonly value: string;
+        /**
+        Recognition confidence
+        */
+        readonly confidence: number;
+        /**
+        Field validation status
+        @defaultValue "NOT_VALIDATED";
+        */
+        readonly validationStatus: RecognitionResult.Field.ValidationStatus;
+        /** @param source {@displayType `DeepPartial<Field>`} */
+        constructor(source?: DeepPartial<Field>);
+    }
+    namespace Field {
+        /**
+        Health insurance card field validation status
+
+        - `NOT_VALIDATED`:
+           Field shouldn't be validated
+        - `FAILURE`:
+           Field is not valid
+        - `SUCCESS`:
+           Field is valid
+        - `CONFIRMED`:
+           Field is valid and confirmed across multiple frames
+        */
+        type ValidationStatus = "NOT_VALIDATED" | "FAILURE" | "SUCCESS" | "CONFIRMED";
+        /**
+        Health insurance card field type
+
+        - `SURNAME`:
+           Surname
+        - `GIVEN_NAME`:
+           Given name
+        - `DATE_OF_BIRTH`:
+           Date of birth
+        - `PERSONAL_IDENTIFICATION_NUMBER`:
+           Personal identification number
+        - `INSTITUTION_NUMBER`:
+           Institution number
+        - `INSTITUTION_NAME`:
+           Institution name
+        - `CARD_NUMBER`:
+           Card number
+        - `CARD_EXPIRATION_DATE`:
+           Card expiration date
+        - `COUNTRY`:
+           Country
+        */
+        type FieldType = "SURNAME" | "GIVEN_NAME" | "DATE_OF_BIRTH" | "PERSONAL_IDENTIFICATION_NUMBER" | "INSTITUTION_NUMBER" | "INSTITUTION_NAME" | "CARD_NUMBER" | "CARD_EXPIRATION_DATE" | "COUNTRY";
+    }
+}
+/**
+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 IssuingCountry = "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";
+/**
+Parameters for frame accumulation
+*/
+export declare class RecognizerParameters extends PartiallyConstructible {
+    /**
+    List of allowed countries for the EHIC. If:
+    - single country: validation rules for the given country are used starting from the first
+                    frame. If the country cannot be inferred or the inferred country doesn't
+                    match the given country, the result of recognize() will be IncompleteValidation.
+    - multiple countries: the country is inferred from the card number first.
+                    Until the country is detected, the document fields are not OCR'd and
+                    accumulated. Once the country is inferred, the field accumulation starts
+                    and the inferred country validation rules are applied.
+                    If the country cannot be inferred or the inferred country doesn't match
+                    any of the countries in the list, the result status will be IncompleteValidation.
+    - empty list: same as "multiple countries" with one additional detail.
+    
+    If the country cannot be inferred within `maxCountryDetectionAttempts` successive frames in which the
+    part of the card number that stores the country code was successfully OCR'd, then the country is
+    inferred to be Unknown and no validation rules are applied. Field accumulation then proceeds normally.
+    In this case recognize() can eventually return Success and the document will have a CountryType of Unknown
+    @defaultValue [];
+    */
+    readonly allowedCountries: IssuingCountry[];
+    /**
+    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;
+    /**
+    Maximum number of attempts before giving up on country detection. After the specified number of
+    attempts, the country field is considered to be unknown and validation is skipped.
+    This option is ignored if allowedCountries is not empty.
+    @defaultValue 5;
+    */
+    readonly maxCountryDetectionAttempts: number;
+    /**
+    Minimum number of accumulated frames that should have equal result for a field.
+    Once satisfied, the corresponding field is considered to be successfully-recognized and won't be considered in the subsequent frames.
+    @defaultValue 4;
+    */
+    readonly minEqualFrameCount: number;
+    /**
+    Maximum number of partial frame results to keep in cache while waiting to gather minEqualFrameCount equal results
+    @defaultValue 10;
+    */
+    readonly maxAccumulatedFrameCount: number;
+    /** @param source {@displayType `DeepPartial<RecognizerParameters>`} */
+    constructor(source?: DeepPartial<RecognizerParameters>);
+}

package/@types/core/bridge/compiled_schemas_v3/FrameUtilities.d.ts

@@ -0,0 +1,18 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+/**
+Configure the frame accumulation process
+*/
+export declare class AccumulatedResultsVerifierConfig extends PartiallyConstructible {
+    /**
+    Maximum number of accumulated frames to inspect to verify a scan result
+    @defaultValue 3;
+    */
+    maximumNumberOfAccumulatedFrames: number;
+    /**
+    Minimum number of accumulated frames that have an equal result in order for the result to be considered verified
+    @defaultValue 2;
+    */
+    minimumNumberOfRequiredFramesWithEqualRecognitionResult: number;
+    /** @param source {@displayType `DeepPartial<AccumulatedResultsVerifierConfig>`} */
+    constructor(source?: DeepPartial<AccumulatedResultsVerifierConfig>);
+}

package/@types/core/bridge/compiled_schemas_v3/GenericDocument.d.ts

@@ -0,0 +1,198 @@
+import { CommonFieldType } from "./CommonFieldType";
+import { DeepPartial, PartiallyConstructible } from "../common";
+import { Point } from "../common";
+import { RawImage } from "../common";
+/**
+Result of OCR text recognition.
+*/
+export declare class OcrResult extends PartiallyConstructible {
+    /**
+    Maximum number of accumulated frames to inspect before actual result is returned.
+    */
+    readonly text: string;
+    /**
+    Minimum number of accumulated frames that have equal result.
+    */
+    readonly confidence: number;
+    /** @param source {@displayType `DeepPartial<OcrResult>`} */
+    constructor(source?: DeepPartial<OcrResult>);
+}
+/**
+Field validation status.
+
+Optical character recognition (OCR) invariably introduces errors in the recognized text.
+There are numerous ways to verify that what has been recognized is, in fact, what was
+written in the document.
+
+The best way to validate the value of a field is for it to have a known format or validation
+logic. For example, an IBAN number has a known format and two check digits that make it
+very unlikely that a value with OCR errors will pass validation. Fields with known
+validation rules will have a validation status of either VALID or INVALID.
+
+Fields whose value can be inferred from other fields, or from domain knowledge (for example,
+the field may have the same value in every instance of this type of document), will have the
+status INFERRED. Inferring the value of a field is a strong validation method, provided that
+there are no unexpected changes to the document format.
+
+Fields that do not have validation rules and cannot be inferred can still be validated by checking whether the same
+value is recognized from multiple attempts, e.g. across multiple frames of a camera stream.
+If the same value is recognized in multiple frames, the value is considered CONFIRMED, otherwise
+it will have the status NONE. This is the least strict validation method, as it does not protect
+from systemic OCR errors, but in practice it still provides good results for most fields.
+
+
+- `INVALID`:
+   Field value failed validation. This status is used for fields that have validation rules, like
+   IBAN, date fields, etc. that have check digits or a known format that can be validated.
+- `NONE`:
+   Field value was not validated, typically because the field does not support validation and the value
+   has not been seen enough times to confirm it.
+   If the same value is seen in multiple frames, the validation status will transition to CONFIRMED,
+   but only if that particular recognizer supports multiple frame accumulation.
+- `CONFIRMED`:
+   The same field value was recognized in multiple frames, thereby confirming the value.
+   Occurs only for fields that have no validation rules otherwise.
+   A CONFIRMED value gives a strong guarantee that the field value has been read out without errors,
+   but not as strong as VALID. The value may still be incorrect, due to systemic OCR errors.
+   In case of OCR errors, increase the number of frames needed to confirm the value in the
+   recognizer configuration
+- `INFERRED`:
+   Field value was inferred from other fields or from domain knowledge.
+   The field value may differ from what is actually written in the document in unexpected situations.
+- `VALID`:
+   Field value passed validation. This status is used for fields that have validation rules, like
+   IBAN, date fields, etc. that have check digits or a known format that can be validated.
+   The VALID status gives the strongest guarantee that the field value has been read out without errors.
+- `IGNORED`:
+   The document contains a field of this type, but recognition for this field is disabled.
+   The value of this field is always empty, although the field may be non-empty in the document.
+*/
+export type ValidationStatus = "INVALID" | "NONE" | "CONFIRMED" | "INFERRED" | "VALID" | "IGNORED";
+/**
+Generic Document Type
+*/
+export declare class FieldType extends PartiallyConstructible {
+    /**
+    Local field type name scoped to the containing document type
+    */
+    readonly name: string;
+    /**
+    Unique global field type name prefixed with the document types of all containing documents
+    */
+    readonly fullName: string;
+    /**
+    Normalized global field type name. Fields in document types derived from the same base document type in the schema will have the same normalized name.
+    */
+    readonly normalizedName: string;
+    /**
+    Commonly occurring fields that have the same semantic meaning in different document types will often have a set common type.
+    */
+    readonly commonType: CommonFieldType | null;
+    /**
+    A document can contain multiple fields of the same name, the property serves for storing natural order of such fields, null if multiple entries aren't allowed for this field
+    @defaultValue null;
+    */
+    readonly listIndex: number | null;
+    /** @param source {@displayType `DeepPartial<FieldType>`} */
+    constructor(source?: DeepPartial<FieldType>);
+}
+/**
+Generic document field
+*/
+export declare class Field extends PartiallyConstructible {
+    /**
+    The type of the field.
+    */
+    readonly type: FieldType;
+    /**
+    Value of the field. Applicable only to text fields.
+    */
+    readonly value: OcrResult | null;
+    /**
+    Confidence weight
+    @defaultValue 1.0;
+    */
+    readonly confidenceWeight: number;
+    /**
+    Crop of the field
+    @defaultValue null;
+    */
+    readonly image: RawImage | null;
+    /**
+    Coordinates of the field in the root document coordinate system
+    */
+    readonly polygonInRoot: Point[];
+    /**
+    Field validation status. Applicable only to fields that support some kind of validation.
+    @defaultValue "NONE";
+    */
+    readonly validationStatus: ValidationStatus;
+    /** @param source {@displayType `DeepPartial<Field>`} */
+    constructor(source?: DeepPartial<Field>);
+}
+/**
+Generic Document Type
+*/
+export declare class GenericDocumentType extends PartiallyConstructible {
+    /**
+    Local document type name
+    */
+    readonly name: string;
+    /**
+    Unique global document type name prefixed with the document types of all containing documents
+    */
+    readonly fullName: string;
+    /**
+    Normalized global document type name. Common document types appearing as child documents in different places will often have the same normalized type name.
+    */
+    readonly normalizedName: string;
+    /**
+    A document can contain multiple fields of the same name, the property serves for storing natural order of such fields, null if multiple entries aren't allowed for this field
+    @defaultValue null;
+    */
+    readonly listIndex: number | null;
+    /** @param source {@displayType `DeepPartial<GenericDocumentType>`} */
+    constructor(source?: DeepPartial<GenericDocumentType>);
+}
+/**
+Generic document
+*/
+export declare class GenericDocument extends PartiallyConstructible {
+    /**
+    Document type
+    */
+    readonly type: GenericDocumentType;
+    /**
+    List of document fields
+    */
+    readonly fields: Field[];
+    /**
+    List of document sub-documents
+    */
+    readonly children: GenericDocument[];
+    /**
+    Coordinates of the document in the parent document coordinate system
+    */
+    readonly quad: Point[] | null;
+    /**
+    Coordinates of the document in the root document coordinate system
+    */
+    readonly quadInRoot: Point[] | null;
+    /**
+    Image crop of the document
+    @defaultValue null;
+    */
+    readonly crop: RawImage | null;
+    /**
+    The average confidence in the accuracy of the document recognition result
+    @defaultValue 0.0;
+    */
+    readonly confidence: number;
+    /**
+    The weight of the confidence. Can be used to calculate the weighted average confidence of two documents.
+    @defaultValue 0.0;
+    */
+    readonly confidenceWeight: number;
+    /** @param source {@displayType `DeepPartial<GenericDocument>`} */
+    constructor(source?: DeepPartial<GenericDocument>);
+}

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

@@ -0,0 +1,104 @@
+import { DeepPartial, PartiallyConstructible } from "../common";
+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 GenericDocumentRecognizerConfig 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[];
+    /**
+    Names of documents that should be recognized
+    @defaultValue [];
+    */
+    acceptedDocumentTypes: string[];
+    /** @param source {@displayType `DeepPartial<GenericDocumentRecognizerConfig>`} */
+    constructor(source?: DeepPartial<GenericDocumentRecognizerConfig>);
+}