@regulaforensics/document-reader 7.1.301-rc

package/www/capacitor/results/Results.js

@@ -0,0 +1,343 @@
+import { exec } from '../internal/bridge';
+import { AuthenticityResult } from "./authenticity/AuthenticityResult";
+import { BarcodeResult } from "./barcode/BarcodeResult";
+import { ImageQualityGroup } from "./image_quality/ImageQualityGroup";
+import { RFIDSessionData } from "./rfid/RFIDSessionData";
+import { ResultsStatus } from "./status/ResultsStatus";
+import { FieldType } from "./visual_results/FieldType";
+import { GraphicFieldType } from "./visual_results/GraphicFieldType";
+import { LCID } from "./visual_results/LCID";
+import { Lights } from "./visual_results/Lights";
+import { GraphicField } from "./visual_results/GraphicField";
+import { GraphicResult } from "./visual_results/GraphicResult";
+import { TextResult } from "./visual_results/TextResult";
+import { TextField } from "./visual_results/TextField";
+import { VDSNCData } from "./visible_digital_seals/VDSNCData";
+import { Position } from "./Position";
+import { DocumentType } from "./DocumentType";
+import { TransactionInfo } from "./TransactionInfo";
+
+export class Results {
+    documentType
+    textResult
+    graphicResult
+    documentPosition
+    barcodePosition
+    mrzPosition
+    imageQuality
+    status
+    authenticityResult
+    rfidSessionData
+    chipPage
+    barcodeResult
+    vdsncData
+    dtcData
+    processingFinishedStatus
+    morePagesAvailable
+    elapsedTime
+    elapsedTimeRFID
+    rawResult
+    transactionInfo
+
+    async textFieldValueByType(fieldType) {
+        return await exec("textFieldValueByType", [
+            this.rawResult,
+            fieldType,
+        ]);
+    }
+
+    async textFieldValueByTypeLcid(fieldType, lcid) {
+        return await exec("textFieldValueByTypeLcid", [
+            this.rawResult,
+            fieldType,
+            lcid,
+        ]);
+    }
+
+    async textFieldValueByTypeSource(fieldType, source) {
+        return await exec("textFieldValueByTypeSource", [
+            this.rawResult,
+            fieldType,
+            source,
+        ]);
+    }
+
+    async textFieldValueByTypeLcidSource(fieldType, lcid, source) {
+        return await exec("textFieldValueByTypeLcidSource", [
+            this.rawResult,
+            fieldType,
+            lcid,
+            source,
+        ]);
+    }
+
+    async textFieldValueByTypeSourceOriginal(fieldType, source, original) {
+        return await exec("textFieldValueByTypeSourceOriginal", [
+            this.rawResult,
+            fieldType,
+            source,
+            original,
+        ]);
+    }
+
+    async textFieldValueByTypeLcidSourceOriginal(fieldType, lcid, source, original) {
+        return await exec("textFieldValueByTypeLcidSourceOriginal", [
+            this.rawResult,
+            fieldType,
+            lcid,
+            source,
+            original,
+        ]);
+    }
+
+    async textFieldByType(fieldType) {
+        const result = await exec("textFieldByType", [
+            this.rawResult,
+            fieldType,
+        ]);
+        if (result == null) return null;
+        return TextField.fromJson(JSON.parse(result));
+    }
+
+    async textFieldByTypeLcid(fieldType, lcid) {
+        const result = await exec("textFieldByTypeLcid", [
+            this.rawResult,
+            fieldType,
+            lcid,
+        ]);
+        if (result == null) return null;
+        return TextField.fromJson(JSON.parse(result));
+    }
+
+    async graphicFieldByTypeSource(fieldType, source) {
+        const result = await exec("graphicFieldByTypeSource", [
+            this.rawResult,
+            fieldType,
+            source,
+        ]);
+        if (result == null) return null;
+        return GraphicField.fromJson(JSON.parse(result));
+    }
+
+    async graphicFieldByTypeSourcePageIndex(fieldType, source, pageIndex) {
+        const result = await exec("graphicFieldByTypeSourcePageIndex", [
+            this.rawResult,
+            fieldType,
+            source,
+            pageIndex,
+        ]);
+        if (result == null) return null;
+        return GraphicField.fromJson(JSON.parse(result));
+    }
+
+    async graphicFieldByTypeSourcePageIndexLight(fieldType, source, pageIndex, light) {
+        const result = await exec("graphicFieldByTypeSourcePageIndexLight", [
+            this.rawResult,
+            fieldType,
+            source,
+            pageIndex,
+            light,
+        ]);
+        if (result == null) return null;
+        return GraphicField.fromJson(JSON.parse(result));
+    }
+
+    async graphicFieldImageByType(fieldType) {
+        const result = await exec("graphicFieldImageByType", [
+            this.rawResult,
+            fieldType,
+        ]);
+        return result;
+    }
+
+    async graphicFieldImageByTypeSource(fieldType, source) {
+        const result = await exec("graphicFieldImageByTypeSource", [
+            this.rawResult,
+            fieldType,
+            source,
+        ]);
+        return result;
+    }
+
+    async graphicFieldImageByTypeSourcePageIndex(fieldType, source, pageIndex) {
+        const result = await exec("graphicFieldImageByTypeSourcePageIndex", [
+            this.rawResult,
+            fieldType,
+            source,
+            pageIndex,
+        ]);
+        return result;
+    }
+
+    async graphicFieldImageByTypeSourcePageIndexLight(fieldType, source, pageIndex, light) {
+        const result = await exec("graphicFieldImageByTypeSourcePageIndexLight", [
+            this.rawResult,
+            fieldType,
+            source,
+            pageIndex,
+            light,
+        ]);
+        return result;
+    }
+
+    async containers(resultType) {
+        return await exec("containers", [this.rawResult, resultType]);
+    }
+
+    async encryptedContainers() {
+        return await exec("encryptedContainers", [this.rawResult]);
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new Results();
+        result.chipPage = jsonObject["chipPage"];
+        result.processingFinishedStatus = jsonObject["processingFinishedStatus"];
+        result.elapsedTime = jsonObject["elapsedTime"];
+        result.elapsedTimeRFID = jsonObject["elapsedTimeRFID"];
+        result.morePagesAvailable = jsonObject["morePagesAvailable"];
+        result.graphicResult = GraphicResult.fromJson(jsonObject["graphicResult"]);
+        result.textResult = TextResult.fromJson(jsonObject["textResult"]);
+        result.rawResult = jsonObject["rawResult"];
+        result.rfidSessionData = RFIDSessionData.fromJson(jsonObject["rfidSessionData"]);
+        result.authenticityResult = AuthenticityResult.fromJson(jsonObject["authenticityResult"]);
+        result.barcodeResult = BarcodeResult.fromJson(jsonObject["barcodeResult"]);
+        result.status = ResultsStatus.fromJson(jsonObject["status"]);
+        result.vdsncData = VDSNCData.fromJson(jsonObject["vdsncData"]);
+        result.dtcData = jsonObject["dtcData"];
+        result.transactionInfo = TransactionInfo.fromJson(jsonObject["transactionInfo"]);
+
+        if (jsonObject["documentPosition"] != null) {
+            result.documentPosition = [];
+            for (const item of jsonObject["documentPosition"]) {
+                const position = Position.fromJson(item);
+                if (position != null) {
+                    result.documentPosition.push(position);
+                }
+            }
+        }
+
+        if (jsonObject["barcodePosition"] != null) {
+            result.barcodePosition = [];
+            for (const item of jsonObject["barcodePosition"]) {
+                const position = Position.fromJson(item);
+                if (position != null) {
+                    result.barcodePosition.push(position);
+                }
+            }
+        }
+
+        if (jsonObject["mrzPosition"] != null) {
+            result.mrzPosition = [];
+            for (const item of jsonObject["mrzPosition"]) {
+                const position = Position.fromJson(item);
+                if (position != null) {
+                    result.mrzPosition.push(position);
+                }
+            }
+        }
+
+        if (jsonObject["imageQuality"] != null) {
+            result.imageQuality = [];
+            for (const item of jsonObject["imageQuality"]) {
+                const imageQualityGroup = ImageQualityGroup.fromJson(item);
+                if (imageQualityGroup != null) {
+                    result.imageQuality.push(imageQualityGroup);
+                }
+            }
+        }
+
+        if (jsonObject["documentType"] != null) {
+            result.documentType = [];
+            for (const item of jsonObject["documentType"]) {
+                const documentType = DocumentType.fromJson(item);
+                if (documentType != null) {
+                    result.documentType.push(documentType);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    toJson() {
+        return {
+            "documentType": this.documentType?.map(e => e.toJson()),
+            "documentPosition": this.documentPosition?.map(e => e.toJson()),
+            "barcodePosition": this.barcodePosition?.map(e => e.toJson()),
+            "mrzPosition": this.mrzPosition?.map(e => e.toJson()),
+            "imageQuality": this.imageQuality?.map(e => e.toJson()),
+            "textResult": this.textResult?.toJson(),
+            "graphicResult": this.graphicResult?.toJson(),
+            "status": this.status?.toJson(),
+            "authenticityResult": this.authenticityResult?.toJson(),
+            "rfidSessionData": this.rfidSessionData?.toJson(),
+            "barcodeResult": this.barcodeResult?.toJson(),
+            "vdsncData": this.vdsncData?.toJson(),
+            "dtcData": this.dtcData,
+            "chipPage": this.chipPage,
+            "processingFinishedStatus": this.processingFinishedStatus,
+            "morePagesAvailable": this.morePagesAvailable,
+            "elapsedTime": this.elapsedTime,
+            "elapsedTimeRFID": this.elapsedTimeRFID,
+            "rawResult": this.rawResult,
+            "transactionInfo": this.transactionInfo?.toJson(),
+        }
+    }
+}
+
+export const ProcessingFinishedStatus = {
+    NOT_READY: 0,
+    READY: 1,
+    TIMEOUT: 2
+};
+
+export const ResultType = {
+    NONE: -1,
+    EMPTY: 0,
+    RAW_IMAGE: 1,
+    FILE_IMAGE: 2,
+    MRZ_OCR_EXTENDED: 3,
+    BARCODES: 5,
+    GRAPHICS: 6,
+    MRZ_TEST_QUALITY: 7,
+    DOCUMENT_TYPES_CANDIDATES: 8,
+    CHOSEN_DOCUMENT_TYPE_CANDIDATE: 9,
+    DOCUMENTS_INFO_LIST: 10,
+    OCR_LEXICAL_ANALYZE: 15,
+    RAW_UNCROPPED_IMAGE: 16,
+    VISUAL_OCR_EXTENDED: 17,
+    BAR_CODES_TEXT_DATA: 18,
+    BAR_CODES_IMAGE_DATA: 19,
+    AUTHENTICITY: 20,
+    EXPERT_ANALYZE: 21,
+    OCR_LEXICAL_ANALYZE_EX: 22,
+    EOS_IMAGE: 23,
+    BAYER_IMAGE: 24,
+    MAGNETIC_STRIPE: 25,
+    MAGNETIC_STRIPE_TEXT_DATA: 26,
+    FIELD_FILE_IMAGE: 27,
+    DATABASE_CHECK: 28,
+    FINGERPRINT_TEMPLATE_ISO: 29,
+    INPUT_IMAGE_QUALITY: 30,
+    LIVE_PORTRAIT: 32,
+    STATUS: 33,
+    PORTRAIT_COMPARISON: 34,
+    EXT_PORTRAIT: 35,
+    TEXT: 36,
+    IMAGES: 37,
+    INTERNAL_RFID_SESSION: 48,
+    INTERNAL_ENCRYPTED_RCL: 49,
+    INTERNAL_LICENSE: 50,
+    MRZ_POSITION: 61,
+    BARCODE_POSITION: 62,
+    DOCUMENT_POSITION: 85,
+    CUSTOM: 100,
+    RFID_RAW_DATA: 101,
+    RFID_TEXT_DATA: 102,
+    RFID_IMAGE_DATA: 103,
+    RFID_BINARY_DATA: 104,
+    RFID_ORIGINAL_GRAPHICS: 105,
+    RFID_DTC_VC: 109
+};

package/www/capacitor/results/TransactionInfo.js

@@ -0,0 +1,24 @@
+export class TransactionInfo {
+    transactionId
+    tag
+    sessionLogFolder
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        var result = new TransactionInfo()
+
+        result.transactionId = jsonObject["transactionId"]
+        result.tag = jsonObject["tag"]
+        result.sessionLogFolder = jsonObject["sessionLogFolder"]
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "transactionId": this.transactionId,
+            "tag": this.tag,
+            "sessionLogFolder": this.sessionLogFolder,
+        }
+    }
+}

package/www/capacitor/results/authenticity/Authenticity.js

@@ -0,0 +1,23 @@
+export const Authenticity = {
+    NONE: 0,
+    UV_LUMINESCENCE: 1,
+    IR_B900: 2,
+    IMAGE_PATTERN: 4,
+    AXIAL_PROTECTION: 8,
+    UV_FIBERS: 16,
+    IR_VISIBILITY: 32,
+    OCR_SECURITY_TEXT: 64,
+    IPI: 128,
+    PHOTO_EMBED_TYPE: 512,
+    OVI: 1024,
+    HOLOGRAMS: 4096,
+    PHOTO_AREA: 8192,
+    PORTRAIT_COMPARISON: 32768,
+    BARCODE_FORMAT_CHECK: 65536,
+    KINEGRAM: 131072,
+    HOLOGRAMS_DETECTION: 524288,
+    LIVENESS: 2097152,
+    OCR: 4194304,
+    MRZ: 8388608,
+    STATUS_ONLY: 2147483648
+}

package/www/capacitor/results/authenticity/AuthenticityCheck.js

@@ -0,0 +1,43 @@
+import { Authenticity } from "./Authenticity";
+import { AuthenticityElement } from "./AuthenticityElement";
+import { CheckResult } from "../status/CheckResult";
+
+export class AuthenticityCheck {
+    type
+    status
+    pageIndex
+    elements
+    typeName
+
+    constructor() {
+        this.elements = []
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new AuthenticityCheck()
+
+        result.type = jsonObject["type"]
+        result.status = jsonObject["status"]
+        result.typeName = jsonObject["typeName"]
+        result.pageIndex = jsonObject["pageIndex"]
+        for (const item of jsonObject["elements"]) {
+            const element = AuthenticityElement.fromJson(item)
+            if (element != null) {
+                result.elements.push(element)
+            }
+        }
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "type": this.type,
+            "status": this.status,
+            "pageIndex": this.pageIndex,
+            "typeName": this.typeName,
+            "elements": this.elements?.map(e => e.toJson()),
+        }
+    }
+}

package/www/capacitor/results/authenticity/AuthenticityElement.js

@@ -0,0 +1,37 @@
+import { SecurityFeatureType } from "./SecurityFeatureType";
+import { CheckDiagnose } from "./CheckDiagnose";
+import { CheckResult } from "../status/CheckResult";
+
+export class AuthenticityElement {
+    status
+    elementType
+    elementDiagnose
+    elementTypeName
+    elementDiagnoseName
+
+    constructor() {
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new AuthenticityElement()
+
+        result.status = jsonObject["status"]
+        result.elementType = jsonObject["elementType"]
+        result.elementDiagnose = jsonObject["elementDiagnose"]
+        result.elementTypeName = jsonObject["elementTypeName"]
+        result.elementDiagnoseName = jsonObject["elementDiagnoseName"]
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "status": this.status,
+            "elementType": this.elementType,
+            "elementDiagnose": this.elementDiagnose,
+            "elementTypeName": this.elementTypeName,
+            "elementDiagnoseName": this.elementDiagnoseName,
+        }
+    }
+}

package/www/capacitor/results/authenticity/AuthenticityResult.js

@@ -0,0 +1,33 @@
+import { AuthenticityCheck } from "./AuthenticityCheck";
+import { CheckResult } from "../status/CheckResult";
+
+export class AuthenticityResult {
+    status
+    checks
+
+    constructor() {
+        this.checks = []
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new AuthenticityResult()
+
+        result.status = jsonObject["status"]
+        for (const item of jsonObject["checks"]) {
+            const check = AuthenticityCheck.fromJson(item)
+            if (check != null) {
+                result.checks.push(check)
+            }
+        }
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "status": this.status,
+            "checks": this.checks?.map(e => e.toJson()),
+        }
+    }
+}

package/www/capacitor/results/authenticity/CheckDiagnose.js

@@ -0,0 +1,125 @@
+export const CheckDiagnose = {
+    PASS: 1,
+    INVALID_INPUT_DATA: 2,
+    INTERNAL_ERROR: 3,
+    EXCEPTION_IN_MODULE: 4,
+    UNCERTAIN_VERIFICATION: 5,
+    NECESSARY_IMAGE_NOT_FOUND: 7,
+    PHOTO_SIDES_NOT_FOUND: 8,
+    INVALID_CHECKSUM: 10,
+    SYNTAX_ERROR: 11,
+    LOGIC_ERROR: 12,
+    SOURCES_COMPARISON_ERROR: 13,
+    FIELDS_COMPARISON_LOGIC_ERROR: 14,
+    INVALID_FIELD_FORMAT: 15,
+    TRUE_LUMINISCENCE_ERROR: 20,
+    FALSE_LUMINISCENCE_ERROR: 21,
+    FIXED_PATTERN_ERROR: 22,
+    LOW_CONTRAST_IN_IR_LIGHT: 23,
+    INCORRECT_BACKGROUND_LIGHT: 24,
+    BACKGROUND_COMPARISON_ERROR: 25,
+    INCORRECT_TEXT_COLOR: 26,
+    PHOTO_FALSE_LUMINISCENCE: 27,
+    TOO_MUCH_SHIFT: 28,
+    CONTACT_CHIP_TYPE_MISMATCH: 29,
+    FIBERS_NOT_FOUND: 30,
+    TOO_MANY_OBJECTS: 31,
+    SPECKS_IN_UV: 33,
+    TOO_LOW_RESOLUTION: 34,
+    INVISIBLE_ELEMENT_PRESENT: 40,
+    VISIBLE_ELEMENT_ABSENT: 41,
+    ELEMENT_SHOULD_BE_COLORED: 42,
+    ELEMENT_SHOULD_BE_GRAYSCALE: 43,
+    PHOTO_WHITE_IR_DONT_MATCH: 44,
+    UV_DULL_PAPER_MRZ: 50,
+    FALSE_LUMINISCENCE_IN_MRZ: 51,
+    UV_DULL_PAPER_PHOTO: 52,
+    UV_DULL_PAPER_BLANK: 53,
+    UV_DULL_PAPER_ERROR: 54,
+    FALSE_LUMINISCENCE_IN_BLANK: 55,
+    BAD_AREA_IN_AXIAL: 60,
+    FALSE_IPI_PARAMETERS: 65,
+    FIELD_POS_CORRECTOR_HIGHLIGHT_IR: 80,
+    FIELD_POS_CORRECTOR_GLARES_IN_PHOTO_AREA: 81,
+    FIELD_POS_CORRECTOR_PHOTO_REPLACED: 82,
+    FIELD_POS_CORRECTOR_LANDMARKS_CHECK_ERROR: 83,
+    FIELD_POS_CORRECTOR_FACE_PRESENCE_CHECK_ERROR: 84,
+    FIELD_POS_CORRECTOR_FACE_ABSENCE_CHECK_ERROR: 85,
+    CHD_FIELD_POS_CORRECTOR_INCORRECT_HEAD_POSITION: 86,
+    OVI_IR_INVISIBLE: 90,
+    OVI_INSUFFICIENT_AREA: 91,
+    OVI_COLOR_INVARIABLE: 92,
+    OVI_BAD_COLOR_FRONT: 93,
+    OVI_BAD_COLOR_SIDE: 94,
+    OVI_WIDE_COLOR_SPREAD: 95,
+    OVI_BAD_COLOR_PERCENT: 96,
+    HOLOGRAM_ELEMENT_ABSENT: 100,
+    HOLOGRAM_SIDE_TOP_IMAGES_ABSENT: 101,
+    HOLOGRAM_ELEMENT_PRESENT: 102,
+    HOLOGRAM_FRAMES_IS_ABSENT: 103,
+    HOLOGRAM_HOLO_FIELD_IS_ABSENT: 104,
+    PHOTO_PATTERN_INTERRUPTED: 110,
+    PHOTO_PATTERN_SHIFTED: 111,
+    PHOTO_PATTERN_DIFFERENT_COLORS: 112,
+    PHOTO_PATTERN_IR_VISIBLE: 113,
+    PHOTO_PATTERN_NOT_INTERSECT: 114,
+    PHOTO_SIZE_IS_WRONG: 115,
+    PHOTO_PATTERN_INVALID_COLOR: 116,
+    PHOTO_PATTERN_SHIFTED_VERT: 117,
+    PHOTO_PATTERN_PATTERN_NOT_FOUND: 118,
+    PHOTO_PATTERN_DIFFERENT_LINES_THICKNESS: 119,
+    PHOTO_IS_NOT_RECTANGLE: 120,
+    PHOTO_CORNERS_IS_WRONG: 121,
+    DOCUMENT_IS_CANCELLING: 122,
+    TEXT_COLOR_SHOULD_BE_BLUE: 130,
+    TEXT_COLOR_SHOULD_BE_GREEN: 131,
+    TEXT_COLOR_SHOULD_BE_RED: 132,
+    TEXT_SHOULD_BE_BLACK: 133,
+    SECURITY_TEXT_IS_ABSENT: 134,
+    BARCODE_WAS_READ_WITH_ERRORS: 140,
+    BARCODE_DATA_FORMAT_ERROR: 141,
+    BARCODE_SIZE_PARAMS_ERROR: 142,
+    NOT_ALL_BARCODES_READ: 143,
+    GLARES_IN_BARCODE_AREA: 144,
+    CHD_NO_CERTIFICATE_FOR_DIGITAL_SIGNATURE_CHECK: 145,
+    PORTRAIT_COMPARISON_PORTRAITS_DIFFER: 150,
+    PORTRAIT_COMPARISON_NO_SERVICE_REPLY: 151,
+    PORTRAIT_COMPARISON_SERVICE_ERROR: 152,
+    PORTRAIT_COMPARISON_NOT_ENOUGH_IMAGES: 153,
+    PORTRAIT_COMPARISON_NO_LIVE_PHOTO: 154,
+    PORTRAIT_COMPARISON_NO_SERVICE_LICENSE: 155,
+    PORTRAIT_COMPARISON_NO_PORTRAIT_DETECTED: 156,
+    MOBILE_IMAGES_UNSUITABLE_LIGHT_CONDITIONS: 160,
+    MOBILE_IMAGES_WHITE_UV_NO_DIFFERENCE: 161,
+    FINGERPRINTS_COMPARISON_MISMATCH: 170,
+    HOLO_PHOTO_FACE_NOT_DETECTED: 180,
+    HOLO_PHOTO_FACE_COMPARISON_FAILED: 181,
+    HOLO_PHOTO_FACE_GLARE_IN_CENTER_ABSENT: 182,
+    HOLO_ELEMENT_SHAPE_ERROR: 183,
+    ALGORITHM_STEPS_ERROR: 184,
+    HOLO_AREAS_NOT_LOADED: 185,
+    FINISHED_BY_TIMEOUT: 186,
+    HOLO_PHOTO_DOCUMENT_OUTSIDE_FRAME: 187,
+    LIVENESS_DEPTH_CHECK_FAILED: 190,
+    MRZ_QUALITY_WRONG_SYMBOL_POSITION: 200,
+    MRZ_QUALITY_WRONG_BACKGROUND: 201,
+    MRZ_QUALITY_WRONG_MRZ_WIDTH: 202,
+    MRZ_QUALITY_WRONG_MRZ_HEIGHT: 203,
+    MRZ_QUALITY_WRONG_LINE_POSITION: 204,
+    MRZ_QUALITY_WRONG_FONT_TYPE: 205,
+    OCR_QUALITY_TEXT_POSITION: 220,
+    OCR_QUALITY_INVALID_FONT: 221,
+    OCR_QUALITY_INVALID_BACKGROUND: 222,
+    LAS_INK_INVALID_LINES_FREQUENCY: 230,
+    DOC_LIVENESS_DOCUMENT_NOT_LIVE: 238,
+    CHD_DOC_LIVENESS_BLACK_AND_WHITE_COPY_DETECTED: 239,
+    DOC_LIVENESS_ELECTRONIC_DEVICE_DETECTED: 240,
+    DOC_LIVENESS_INVALID_BARCODE_BACKGROUND: 241,
+    ICAO_IDB_BASE_32_ERROR: 243,
+    ICAO_IDB_ZIPPED_ERROR: 244,
+    ICAO_IDB_MESSAGE_ZONE_EMPTY: 245,
+    ICAO_IDB_SIGNATURE_MUST_BE_PRESENT: 246,
+    ICAO_IDB_SIGNATURE_MUST_NOT_BE_PRESENT: 247,
+    ICAO_IDB_CERTIFICATE_MUST_NOT_BE_PRESENT: 248,
+    INCORRECT_OBJECT_COLOR: 250
+}

package/www/capacitor/results/authenticity/SecurityFeatureType.js

@@ -0,0 +1,59 @@
+export const SecurityFeatureType = {
+    NONE: -1,
+    BLANK: 0,
+    FILL: 1,
+    PHOTO: 2,
+    MRZ: 3,
+    FALSE_LUMINESCENCE: 4,
+    HOLO_SIMPLE: 5,
+    HOLO_VERIFY_STATIC: 6,
+    HOLO_VERIFY_MULTI_STATIC: 7,
+    HOLO_VERIFY_DINAMIC: 8,
+    PATTERN_NOT_INTERRUPTED: 9,
+    PATTERN_NOT_SHIFTED: 10,
+    PATTERN_SAME_COLORS: 11,
+    PATTERN_IR_INVISIBLE: 12,
+    PHOTO_SIZE_CHECK: 13,
+    PORTRAIT_COMPARISON_VS_GHOST: 14,
+    PORTRAIT_COMPARISON_VS_RFID: 15,
+    PORTRAIT_COMPARISON_VS_VISUAL: 16,
+    BARCODE: 17,
+    PATTERN_DIFFERENT_LINES_THICKNESS: 18,
+    PORTRAIT_COMPARISON_VS_CAMERA: 19,
+    PORTRAIT_COMPARISON_RFID_VS_CAMERA: 20,
+    GHOST_PHOTO: 21,
+    CLEAR_GHOST_PHOTO: 22,
+    INVISIBLE_OBJECT: 23,
+    LOW_CONTRAST_OBJECT: 24,
+    PHOTO_COLOR: 25,
+    PHOTO_SHAPE: 26,
+    PHOTO_CORNERS: 27,
+    DOCUMENT_CANCELLING_DETECTOR: 28,
+    OCR: 28,
+    PORTRAIT_COMPARISON_EXTVS_VISUAL: 29,
+    PORTRAIT_COMPARISON_EXTVS_RFID: 30,
+    PORTRAIT_COMPARISON_EXTVS_LIVE: 31,
+    LIVENESS_DEPTH: 32,
+    MICROTEXT: 33,
+    FLUORESCENT_OBJECT: 34,
+    LANDMARKS_CHECK: 35,
+    FACE_PRESENCE: 36,
+    FACE_ABSENCE: 38,
+    LIVENESS_SCREEN_CAPTURE: 39,
+    LIVENESS_ELECTRONIC_DEVICE: 40,
+    LIVENESS_OVI: 41,
+    BARCODE_SIZE_CHECK: 42,
+    LAS_INK: 43,
+    LIVENESS_MLI: 44,
+    LIVENESS_BARCODE_BACKGROUND: 45,
+    PORTRAIT_COMPARISON_VS_BARCODE: 46,
+    PORTRAIT_COMPARISON_RFID_VS_BARCODE: 47,
+    PORTRAIT_COMPARISON_EXT_VS_BARCODE: 48,
+    PORTRAIT_COMPARISON_BARCODE_VS_CAMERA: 49,
+    CHECK_DIGITAL_SIGNATURE: 50,
+    CONTACT_CHIP_CLASSIFICATION: 51,
+    HEAD_POSITION_CHECK: 52,
+    LIVENESS_BLACK_AND_WHITE_COPY_CHECK: 53,
+    LIVENESS_DYNAPRINT: 54,
+    LIVENESS_GEOMETRY_CHECK: 55
+}