@regulaforensics/document-reader 8.2.186-beta

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

@@ -0,0 +1,33 @@
+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
+    }
+}

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

@@ -0,0 +1,27 @@
+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
+    }
+}

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

@@ -0,0 +1,26 @@
+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
+    }
+}

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

@@ -0,0 +1,124 @@
+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,
+    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
+}

package/www/capacitor/results/barcode/BarcodeField.js

@@ -0,0 +1,24 @@
+import { BarcodeStatus } from "./BarcodeStatus";
+import { BarcodeType } from "./BarcodeType";
+import { PDF417Info } from "./PDF417Info";
+
+export class BarcodeField {
+    barcodeType
+    status
+    pdf417Info
+    data
+    pageIndex
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new BarcodeField();
+        result.barcodeType = jsonObject["barcodeType"];
+        result.status = jsonObject["status"];
+        result.pageIndex = jsonObject["pageIndex"];
+        result.pdf417Info = PDF417Info.fromJson(jsonObject["pdf417Info"]);
+        result.data = jsonObject["data"];
+        
+        return result;
+    }
+}

package/www/capacitor/results/barcode/BarcodeResult.js

@@ -0,0 +1,24 @@
+import { BarcodeField } from "./BarcodeField";
+
+export class BarcodeResult {
+    constructor() {
+        this.fields = [];
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new BarcodeResult();
+        
+        if (jsonObject["fields"] != null) {
+            for (const item of jsonObject["fields"]) {
+                const field = BarcodeField.fromJson(item);
+                if (field != null) {
+                    result.fields.push(field);
+                }
+            }
+        }
+        
+        return result;
+    }
+}

package/www/capacitor/results/barcode/BarcodeStatus.js

@@ -0,0 +1,33 @@
+export const BarcodeStatus = {
+    NO_ERR: 0,
+    INVALID_RESULT: 140,
+    NULL_PTR_ERR: -6001,
+    BAD_ARG_ERR: -6002,
+    SIZE_ERR: -6003,
+    RANGE_ERR: -6004,
+    INTERNAL_ERR: -6005,
+    TRY_EXCEPT_ERR: -6006,
+    BAR_CODE_NOT_FOUND: -6008,
+    BAR_CODE_DECODE_ERR: -6010,
+    NO_USER_DLL_FOUND: -6019,
+    NO_IPP_DLL_FOUND: -6020,
+    IPP_EXEC_ERR: -6024,
+    IPP_TRY_EXCEPT_ERR: -6025,
+    BARCODE_ERROR_INPUT_PARAM: -11001,
+    BARCODE_ERROR_FINIT: -11006,
+    BARCODE_ERROR_NOT_LOAD_IP_DECODED_LL: -11012,
+    BARCODE_ERROR_INNER_PROBLEM: -11100,
+    BARCODE_ERROR_DECODE_1D_BAD_DECODE: -11200,
+    BARCODE_ERROR_FIND_ROW_OR_COLUMN: -11201,
+    BARCODE_ERROR_FIND_3X8_2D_X: -11202,
+    BARCODE_ERROR_FIND_3X8_2D_Y: -11203,
+    BARCODE_ERROR_2D_UGOL_MAX: -11204,
+    BARCODE_ERROR_INDEFINITELY_DECODED: -11210,
+    BARCODE_ERROR_DLL_NOT_INIT: -11300,
+    BARCODE_ERROR_IP_DECODE_DLL_Try_Except: -11400,
+    IPDECODE_ERROR_LARGEERRORS: -4503,
+    IPDECODE_ERROR_FAULTCOLUMNS: -4504,
+    IPDECODE_ERROR_FAULTROWS: -4505,
+    IPDECODE_ERROR_INCORRECT_ERROR_LEVEL: -4511,
+    IPDECODE_ERROR_LOADING_DEV_TABLE: -4512
+}

package/www/capacitor/results/barcode/BarcodeType.js

@@ -0,0 +1,21 @@
+export const BarcodeType = {
+    BCT_CODE128: 1,
+    CODE39: 2,
+    EAN8: 3,
+    ITF: 4,
+    PDF417: 5,
+    STF: 6,
+    MTF: 7,
+    IATA: 8,
+    CODABAR: 9,
+    UPCA: 10,
+    CODE93: 11,
+    UPCE: 12,
+    EAN13: 13,
+    QRCODE: 14,
+    AZTEC: 15,
+    DATAMATRIX: 16,
+    ALL_1D: 17,
+    CODE11: 18,
+    JABCODE: 19
+}

package/www/capacitor/results/barcode/PDF417Info.js

@@ -0,0 +1,16 @@
+export class PDF417Info {
+    errorLevel
+    columns
+    rows
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new PDF417Info();
+        result.errorLevel = jsonObject["errorLevel"];
+        result.columns = jsonObject["columns"];
+        result.rows = jsonObject["rows"];
+        
+        return result;
+    }
+}

package/www/capacitor/results/image_quality/ImageQuality.js

@@ -0,0 +1,31 @@
+import { CheckResult } from "../status/CheckResult";
+import { Rect } from "../visual_results/Rect";
+import { ImageQualityCheckType } from "./ImageQualityCheckType";
+
+export class ImageQuality {
+    featureType
+    result
+    type
+    boundRects
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new ImageQuality();
+        result.featureType = jsonObject["featureType"];
+        result.result = jsonObject["result"];
+        result.type = jsonObject["type"];
+        
+        if (jsonObject["boundRects"] != null) {
+            result.boundRects = [];
+            for (const item of jsonObject["boundRects"]) {
+                const rect = Rect.fromJson(item);
+                if (rect != null) {
+                    result.boundRects.push(rect);
+                }
+            }
+        }
+        
+        return result;
+    }
+}

package/www/capacitor/results/image_quality/ImageQualityCheckType.js

@@ -0,0 +1,19 @@
+import { exec } from "../../internal/bridge";
+
+export const ImageQualityCheckType = {
+    IMAGE_GLARES: 0,
+    IMAGE_FOCUS: 1,
+    IMAGE_RESOLUTION: 2,
+    IMAGE_COLORNESS: 3,
+    PERSPECTIVE: 4,
+    BOUNDS: 5,
+    SCREEN_CAPTURE: 6,
+    PORTRAIT: 7,
+    HANDWRITTEN: 8,
+    BRIGHTNESS: 9,
+    OCCLUSION: 10
+}
+
+ImageQualityCheckType.getTranslation = async function (value) {
+    return await exec("getTranslation", ["ImageQualityCheckType", value]);
+}

package/www/capacitor/results/image_quality/ImageQualityGroup.js

@@ -0,0 +1,30 @@
+import { CheckResult } from "../status/CheckResult";
+import { ImageQuality } from "./ImageQuality";
+
+export class ImageQualityGroup {
+    count
+    result
+    imageQualityList
+    pageIndex
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new ImageQualityGroup();
+        result.count = jsonObject["count"];
+        result.result = jsonObject["result"];
+        result.pageIndex = jsonObject["pageIndex"];
+        
+        if (jsonObject["imageQualityList"] != null) {
+            result.imageQualityList = [];
+            for (const item of jsonObject["imageQualityList"]) {
+                const imageQuality = ImageQuality.fromJson(item);
+                if (imageQuality != null) {
+                    result.imageQualityList.push(imageQuality);
+                }
+            }
+        }
+        
+        return result;
+    }
+}

package/www/capacitor/results/rfid/AccessControlProcedureType.js

@@ -0,0 +1,21 @@
+import { RFIDErrorCodes } from "../../rfid/RFIDErrorCodes";
+import { RFIDAccessControlProcedureType } from "./RFIDAccessControlProcedureType";
+
+export class AccessControlProcedureType {
+    activeOptionIdx
+    notifications
+    status
+    type
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new AccessControlProcedureType();
+        result.activeOptionIdx = jsonObject["activeOptionIdx"];
+        result.status = jsonObject["status"];
+        result.type = jsonObject["type"];
+        result.notifications = jsonObject["notifications"];
+        
+        return result;
+    }
+}

package/www/capacitor/results/rfid/Application.js

@@ -0,0 +1,47 @@
+import { File } from "./File";
+import { RFIDErrorCodes } from '../../rfid/RFIDErrorCodes';
+
+export class Application {
+    applicationID
+    dataHashAlgorithm
+    files
+    status
+    type
+    unicodeVersion
+    version
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new Application();
+        result.applicationID = jsonObject["applicationID"];
+        result.dataHashAlgorithm = jsonObject["dataHashAlgorithm"];
+        result.status = jsonObject["status"];
+        result.type = jsonObject["type"];
+        result.unicodeVersion = jsonObject["unicodeVersion"];
+        result.version = jsonObject["version"];
+        
+        if (jsonObject["files"] != null) {
+            result.files = [];
+            for (const item of jsonObject["files"]) {
+                const file = File.fromJson(item);
+                if (file != null) {
+                    result.files.push(file);
+                }
+            }
+        }
+        
+        return result;
+    }
+}
+
+export const RFIDApplicationType = {
+    E_PASSPORT: 1,
+    E_ID: 2,
+    E_SIGN: 3,
+    E_DL: 4,
+    LDS2_TRAVEL_RECORDS: 5,
+    LDS2_VISA_RECORDS: 6,
+    LDS2_ADD_BIOMETRICS: 7,
+    E_DTC_PC: 8
+}

package/www/capacitor/results/rfid/Attribute.js

@@ -0,0 +1,16 @@
+import { RFIDValue } from './RFIDValue';
+
+export class Attribute {
+    type
+    value
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new Attribute();
+        result.type = jsonObject["type"];
+        result.value = RFIDValue.fromJson(jsonObject["value"]);
+        
+        return result;
+    }
+}

package/www/capacitor/results/rfid/Authority.js

@@ -0,0 +1,28 @@
+import { Attribute } from './Attribute';
+import { RFIDValue } from './RFIDValue';
+
+export class Authority {
+    attributes
+    data
+    friendlyName
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new Authority();
+        result.data = jsonObject["data"];
+        result.friendlyName = RFIDValue.fromJson(jsonObject["friendlyName"]);
+        
+        if (jsonObject["attributes"] != null) {
+            result.attributes = [];
+            for (const item of jsonObject["attributes"]) {
+                const attribute = Attribute.fromJson(item);
+                if (attribute != null) {
+                    result.attributes.push(attribute);
+                }
+            }
+        }
+        
+        return result;
+    }
+}

package/www/capacitor/results/rfid/CardProperties.js

@@ -0,0 +1,38 @@
+export class CardProperties {
+    aTQA
+    aTQB
+    aTR
+    baudrate1
+    baudrate2
+    bitRateR
+    bitRateS
+    chipTypeA
+    mifareMemory
+    rfidType
+    sAK
+    support4
+    supportMifare
+    uID
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new CardProperties();
+        result.aTQA = jsonObject["aTQA"];
+        result.aTQB = jsonObject["aTQB"];
+        result.aTR = jsonObject["aTR"];
+        result.baudrate1 = jsonObject["baudrate1"];
+        result.baudrate2 = jsonObject["baudrate2"];
+        result.bitRateR = jsonObject["bitRateR"];
+        result.bitRateS = jsonObject["bitRateS"];
+        result.chipTypeA = jsonObject["chipTypeA"];
+        result.mifareMemory = jsonObject["mifareMemory"];
+        result.rfidType = jsonObject["rfidType"];
+        result.sAK = jsonObject["sAK"];
+        result.support4 = jsonObject["support4"];
+        result.supportMifare = jsonObject["supportMifare"];
+        result.uID = jsonObject["uID"];
+        
+        return result;
+    }
+}

package/www/capacitor/results/rfid/CertificateChain.js

@@ -0,0 +1,51 @@
+import { Authority } from "./Authority";
+import { Extension } from "./Extension";
+import { RFIDCertificateType } from "./RFIDCertificateType";
+import { RFIDValidity } from "./RFIDValidity";
+import { RFIDValue } from "./RFIDValue";
+
+export class CertificateChain {
+    type
+    extensions
+    fileName
+    issuer
+    notifications
+    origin
+    paStatus
+    serialNumber
+    signatureAlgorithm
+    subject
+    subjectPKAlgorithm
+    validity
+    version
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new CertificateChain();
+        result.type = jsonObject["type"];
+        result.origin = jsonObject["origin"];
+        result.paStatus = jsonObject["paStatus"];
+        result.version = jsonObject["version"];
+        result.serialNumber = jsonObject["serialNumber"];
+        result.signatureAlgorithm = jsonObject["signatureAlgorithm"];
+        result.subjectPKAlgorithm = jsonObject["subjectPKAlgorithm"];
+        result.fileName = RFIDValue.fromJson(jsonObject["fileName"]);
+        result.issuer = Authority.fromJson(jsonObject["issuer"]);
+        result.subject = Authority.fromJson(jsonObject["subject"]);
+        result.validity = RFIDValidity.fromJson(jsonObject["validity"]);
+        result.notifications = jsonObject["notifications"];
+        
+        if (jsonObject["extensions"] != null) {
+            result.extensions = [];
+            for (const item of jsonObject["extensions"]) {
+                const extension = Extension.fromJson(item);
+                if (extension != null) {
+                    result.extensions.push(extension);
+                }
+            }
+        }
+        
+        return result;
+    }
+}