@regulaforensics/document-reader 7.1.301-rc

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

@@ -0,0 +1,10 @@
+export const RFIDAccessControlProcedureType = {
+  UNDEFINED: 0,
+  BAC: 1,
+  PACE: 2,
+  CA: 3,
+  TA: 4,
+  AA: 5,
+  RI: 6,
+  CARD_INFO: 10
+};

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

@@ -0,0 +1,13 @@
+export const RFIDCertificateType = {
+  UNDEFINED: 0,
+  CSCA: 1,
+  CSCA_LINK: 2,
+  DS: 3,
+  MLS: 4,
+  DEV_LS: 5,
+  DEF_LS: 6,
+  BLS: 7,
+  LDS2: 8,
+  BCS: 9,
+  BCSNC: 10
+};

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

@@ -0,0 +1,98 @@
+import { exec } from "../../internal/bridge";
+
+export const RFIDDataFileType = {
+  UNSPECIFIED: 0,
+  PASSPORT_DG1: 1,
+  PASSPORT_DG2: 2,
+  PASSPORT_DG3: 3,
+  PASSPORT_DG4: 4,
+  PASSPORT_DG5: 5,
+  PASSPORT_DG6: 6,
+  PASSPORT_DG7: 7,
+  PASSPORT_DG8: 8,
+  PASSPORT_DG9: 9,
+  PASSPORT_DG10: 10,
+  PASSPORT_DG11: 11,
+  PASSPORT_DG12: 12,
+  PASSPORT_DG13: 13,
+  PASSPORT_DG14: 14,
+  PASSPORT_DG15: 15,
+  PASSPORT_DG16: 16,
+  PASSPORT_DG17: 17,
+  PASSPORT_DG18: 18,
+  PASSPORT_DG19: 19,
+  PASSPORT_DG20: 20,
+  PASSPORT_SOD: 21,
+  PASSPORT_CVCA: 22,
+  PASSPORT_COM: 23,
+  DTC_DG17: 57,
+  DTC_DG18: 58,
+  DTC_DG22: 62,
+  DTC_DG23: 63,
+  DTC_DG24: 64,
+  ID_DG1: 101,
+  ID_DG2: 102,
+  ID_DG3: 103,
+  ID_DG4: 104,
+  ID_DG5: 105,
+  ID_DG6: 106,
+  ID_DG7: 107,
+  ID_DG8: 108,
+  ID_DG9: 109,
+  ID_DG10: 110,
+  ID_DG11: 111,
+  ID_DG12: 112,
+  ID_DG13: 113,
+  ID_DG14: 114,
+  ID_DG15: 115,
+  ID_DG16: 116,
+  ID_DG17: 117,
+  ID_DG18: 118,
+  ID_DG19: 119,
+  ID_DG20: 120,
+  ID_DG21: 121,
+  DL_COM: 150,
+  DL_DG1: 151,
+  DL_DG2: 152,
+  DL_DG3: 153,
+  DL_DG4: 154,
+  DL_DG5: 155,
+  DL_DG6: 156,
+  DL_DG7: 157,
+  DL_DG8: 158,
+  DL_DG9: 159,
+  DL_DG10: 160,
+  DL_DG11: 161,
+  DL_DG12: 162,
+  DL_DG13: 163,
+  DL_DG14: 164,
+  DL_SOD: 165,
+  DL_CE: 166,
+  DL_CVCA: 167,
+  PACE_CARDACCESS: 200,
+  PACE_CARDSECURITY: 201,
+  PACE_CHIPSECURITY: 202,
+  MIFARE_DATA: 300,
+  MIFARE_VALIDITY: 301,
+  AUTHENTICITYV2: 302,
+  ATR: 400,
+  ESIGN_PK: 500,
+  ESIGN_SIGNEDDATA: 501,
+  CERTIFICATE: 600,
+  MASTERLIST: 601,
+  DEFECTLIST: 602,
+  DEVIATIONLIST: 603,
+  APP_DIRECTORY: 700,
+  SESSION: 701,
+  LOGDATA: 702,
+  CHIP_PROPERTIES: 703,
+  SAM_DATA: 800,
+  SAM_DATA_MAX: 832,
+  VDS: 900,
+  VDSNC: 901,
+  USERDEFINED: 1000
+};
+
+RFIDDataFileType.getTranslation = async function (value) {
+  return await exec("getTranslation", ["RFIDDataFileType", value]);
+}

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

@@ -0,0 +1,92 @@
+import { AccessControlProcedureType } from './AccessControlProcedureType';
+import { Application } from './Application';
+import { SecurityObject } from './SecurityObject';
+import { CardProperties } from './CardProperties';
+import { RFIDErrorCodes } from '../../rfid/RFIDErrorCodes';
+import { DataField } from './DataField';
+import { RFIDDataFileType } from './RFIDDataFileType';
+
+export class RFIDSessionData {
+    accessControls
+    applications
+    securityObjects
+    cardProperties
+    totalBytesReceived
+    totalBytesSent
+    status
+    extLeSupport
+    processTime
+    dataFields
+    dataGroups
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new RFIDSessionData();
+        result.totalBytesReceived = jsonObject["totalBytesReceived"];
+        result.totalBytesSent = jsonObject["totalBytesSent"];
+        result.status = jsonObject["status"];
+        result.extLeSupport = jsonObject["extLeSupport"];
+        result.processTime = jsonObject["processTime"];
+        result.cardProperties = CardProperties.fromJson(jsonObject["cardProperties"]);
+        result.dataGroups = jsonObject["dataGroups"];
+
+        if (jsonObject["accessControls"]) {
+            result.accessControls = [];
+            for (const item of jsonObject["accessControls"]) {
+                const accessControl = AccessControlProcedureType.fromJson(item);
+                if (accessControl) {
+                    result.accessControls.push(accessControl);
+                }
+            }
+        }
+
+        if (jsonObject["applications"]) {
+            result.applications = [];
+            for (const item of jsonObject["applications"]) {
+                const application = Application.fromJson(item);
+                if (application) {
+                    result.applications.push(application);
+                }
+            }
+        }
+
+        if (jsonObject["securityObjects"]) {
+            result.securityObjects = [];
+            for (const item of jsonObject["securityObjects"]) {
+                const securityObject = SecurityObject.fromJson(item);
+                if (securityObject) {
+                    result.securityObjects.push(securityObject);
+                }
+            }
+        }
+
+        if (jsonObject["dataFields"]) {
+            result.dataFields = [];
+            for (const item of jsonObject["dataFields"]) {
+                const dataField = DataField.fromJson(item);
+                if (dataField) {
+                    result.dataFields.push(dataField);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    toJson() {
+        return {
+            "cardProperties": this.cardProperties?.toJson(),
+            "totalBytesReceived": this.totalBytesReceived,
+            "totalBytesSent": this.totalBytesSent,
+            "status": this.status,
+            "extLeSupport": this.extLeSupport,
+            "processTime": this.processTime,
+            "accessControls": this.accessControls?.map(e => e.toJson()),
+            "applications": this.applications?.map(e => e.toJson()),
+            "securityObjects": this.securityObjects?.map(e => e.toJson()),
+            "dataFields": this.dataFields?.map(e => e.toJson()),
+            "dataGroups": this.dataGroups,
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+import { RFIDValue } from './RFIDValue';
+
+export class RFIDValidity {
+    notAfter
+    notBefore
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new RFIDValidity();
+        result.notAfter = RFIDValue.fromJson(jsonObject["notAfter"]);
+        result.notBefore = RFIDValue.fromJson(jsonObject["notBefore"]);
+
+        return result;
+    }
+
+    toJson() {
+        return {
+            "notAfter": this.notAfter?.toJson(),
+            "notBefore": this.notBefore?.toJson(),
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+export class RFIDValue {
+    data
+    length
+    status
+    type
+    format
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new RFIDValue();
+        result.length = jsonObject["length"];
+        result.type = jsonObject["type"];
+        result.status = jsonObject["status"];
+        result.data = jsonObject["data"];
+        result.format = jsonObject["format"];
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "data": this.data,
+            "length": this.length,
+            "status": this.status,
+            "type": this.type,
+            "format": this.format,
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+import { SignerInfo } from './SignerInfo';
+
+export class SecurityObject {
+    fileReference
+    objectType
+    version
+    signerInfos
+    notifications
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new SecurityObject();
+        result.fileReference = jsonObject["fileReference"];
+        result.version = jsonObject["version"];
+        result.objectType = jsonObject["objectType"];
+        result.notifications = jsonObject["notifications"];
+
+        if (jsonObject["signerInfos"]) {
+            result.signerInfos = [];
+            for (const item of jsonObject["signerInfos"]) {
+                const signerInfo = SignerInfo.fromJson(item);
+                if (signerInfo) {
+                    result.signerInfos.push(signerInfo);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    toJson() {
+        return {
+            "fileReference": this.fileReference,
+            "objectType": this.objectType,
+            "version": this.version,
+            "signerInfos": this.signerInfos?.map(e => e.toJson()),
+            "notifications": this.notifications,
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { CertificateData } from './CertificateData';
+
+export class SecurityObjectCertificates {
+    securityObject
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new SecurityObjectCertificates();
+        result.securityObject = CertificateData.fromJson(jsonObject["securityObject"]);
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "securityObject": this.securityObject?.toJson(),
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+import { Authority } from './Authority';
+import { RFIDValue } from './RFIDValue';
+import { Extension } from './Extension';
+import { CertificateChain } from './CertificateChain';
+
+export class SignerInfo {
+    dataToHash
+    digestAlgorithm
+    paStatus
+    signatureAlgorithm
+    version
+    issuer
+    serialNumber
+    signature
+    signedAttributes
+    subjectKeyIdentifier
+    certificateChain
+    notifications
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new SignerInfo();
+        result.dataToHash = jsonObject["dataToHash"];
+        result.digestAlgorithm = jsonObject["digestAlgorithm"];
+        result.paStatus = jsonObject["paStatus"];
+        result.signatureAlgorithm = jsonObject["signatureAlgorithm"];
+        result.version = jsonObject["version"];
+        result.issuer = Authority.fromJson(jsonObject["issuer"]);
+        result.serialNumber = RFIDValue.fromJson(jsonObject["serialNumber"]);
+        result.signature = RFIDValue.fromJson(jsonObject["signature"]);
+        result.subjectKeyIdentifier = RFIDValue.fromJson(jsonObject["subjectKeyIdentifier"]);
+        result.notifications = jsonObject["notifications"];
+        
+        if (jsonObject["signedAttributes"] != null) {
+            result.signedAttributes = [];
+            for (const item of jsonObject["signedAttributes"]) {
+                const extension = Extension.fromJson(item);
+                if (extension != null) {
+                    result.signedAttributes.push(extension);
+                }
+            }
+        }
+        
+        if (jsonObject["certificateChain"] != null) {
+            result.certificateChain = [];
+            for (const item of jsonObject["certificateChain"]) {
+                const certificateChainItem = CertificateChain.fromJson(item);
+                if (certificateChainItem != null) {
+                    result.certificateChain.push(certificateChainItem);
+                }
+            }
+        }
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "dataToHash": this.dataToHash,
+            "digestAlgorithm": this.digestAlgorithm,
+            "version": this.version,
+            "paStatus": this.paStatus,
+            "signatureAlgorithm": this.signatureAlgorithm,
+            "issuer": this.issuer?.toJson(),
+            "serialNumber": this.serialNumber?.toJson(),
+            "signature": this.signature?.toJson(),
+            "subjectKeyIdentifier": this.subjectKeyIdentifier?.toJson(),
+            "signedAttributes": this.signedAttributes?.map(e => e.toJson()),
+            "certificateChain": this.certificateChain?.map(e => e.toJson()),
+            "notifications": this.notifications,
+        }
+    }
+}

package/www/capacitor/results/status/CheckResult.js

@@ -0,0 +1,5 @@
+export const CheckResult = {
+    ERROR: 0,
+    OK: 1,
+    WAS_NOT_DONE: 2
+};

package/www/capacitor/results/status/OpticalStatus.js

@@ -0,0 +1,44 @@
+import { CheckResult } from './CheckResult';
+
+export class OpticalStatus {
+    overallStatus
+    mrz
+    text
+    docType
+    security
+    imageQA
+    expiry
+    vds
+    pagesCount
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new OpticalStatus();
+        result.overallStatus = jsonObject["overallStatus"];
+        result.mrz = jsonObject["mrz"];
+        result.text = jsonObject["text"];
+        result.docType = jsonObject["docType"];
+        result.security = jsonObject["security"];
+        result.imageQA = jsonObject["imageQA"];
+        result.expiry = jsonObject["expiry"];
+        result.vds = jsonObject["vds"];
+        result.pagesCount = jsonObject["pagesCount"];
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "overallStatus": this.overallStatus,
+            "mrz": this.mrz,
+            "text": this.text,
+            "docType": this.docType,
+            "security": this.security,
+            "imageQA": this.imageQA,
+            "expiry": this.expiry,
+            "vds": this.vds,
+            "pagesCount": this.pagesCount,
+        }
+    }
+}

package/www/capacitor/results/status/RFIDStatus.js

@@ -0,0 +1,38 @@
+import { CheckResult } from './CheckResult';
+
+export class RFIDStatus {
+    overallStatus
+    pa
+    ca
+    aa
+    ta
+    bac
+    pace
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new RFIDStatus();
+        result.pa = jsonObject["pa"];
+        result.ca = jsonObject["ca"];
+        result.aa = jsonObject["aa"];
+        result.ta = jsonObject["ta"];
+        result.bac = jsonObject["bac"];
+        result.pace = jsonObject["pace"];
+        result.overallStatus = jsonObject["overallStatus"];
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "overallStatus": this.overallStatus,
+            "pa": this.pa,
+            "ca": this.ca,
+            "aa": this.aa,
+            "ta": this.ta,
+            "bac": this.bac,
+            "pace": this.pace,
+        }
+    }
+}

package/www/capacitor/results/status/ResultsStatus.js

@@ -0,0 +1,40 @@
+import { CheckResult } from './CheckResult';
+import { OpticalStatus } from './OpticalStatus';
+import { RFIDStatus } from './RFIDStatus';
+
+export class ResultsStatus {
+    overallStatus
+    optical
+    detailsOptical
+    rfid
+    detailsRFID
+    portrait
+    stopList
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new ResultsStatus();
+        result.overallStatus = jsonObject["overallStatus"];
+        result.optical = jsonObject["optical"];
+        result.detailsOptical = OpticalStatus.fromJson(jsonObject["detailsOptical"]);
+        result.rfid = jsonObject["rfid"];
+        result.detailsRFID = RFIDStatus.fromJson(jsonObject["detailsRFID"]);
+        result.portrait = jsonObject["portrait"];
+        result.stopList = jsonObject["stopList"];
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "overallStatus": this.overallStatus,
+            "optical": this.optical,
+            "rfid": this.rfid,
+            "portrait": this.portrait,
+            "stopList": this.stopList,
+            "detailsOptical": this.detailsOptical?.toJson(),
+            "detailsRFID": this.detailsRFID?.toJson(),
+        }
+    }
+}

package/www/capacitor/results/visible_digital_seals/BytesData.js

@@ -0,0 +1,27 @@
+export class BytesData {
+    data
+    length
+    status
+    type
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new BytesData();
+        result.data = jsonObject["data"];
+        result.length = jsonObject["length"];
+        result.status = jsonObject["status"];
+        result.type = jsonObject["type"];
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "data": this.data,
+            "length": this.length,
+            "status": this.status,
+            "type": this.type,
+        }
+    }
+}