@regulaforensics/document-reader 7.1.301-rc

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

@@ -0,0 +1,34 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "barcodeType": this.barcodeType,
+            "status": this.status,
+            "pdf417Info": this.pdf417Info?.toJson(),
+            "data": this.data,
+            "pageIndex": this.pageIndex,
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "fields": this.fields?.map(e => e.toJson()),
+        }
+    }
+}

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,24 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "errorLevel": this.errorLevel,
+            "columns": this.columns,
+            "rows": this.rows,
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "featureType": this.featureType,
+            "result": this.result,
+            "type": this.type,
+            "boundRects": this.boundRects?.map(e => e.toJson()),
+        }
+    }
+}

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,39 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "count": this.count,
+            "result": this.result,
+            "pageIndex": this.pageIndex,
+            "imageQualityList": this.imageQualityList?.map(e => e.toJson()),
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "activeOptionIdx": this.activeOptionIdx,
+            "notifications": this.notifications,
+            "status": this.status,
+            "type": this.type,
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "applicationID": this.applicationID,
+            "dataHashAlgorithm": this.dataHashAlgorithm,
+            "files": this.files?.map(e => e.toJson()),
+            "status": this.status,
+            "type": this.type,
+            "unicodeVersion": this.unicodeVersion,
+            "version": this.version,
+        }
+    }
+}
+
+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,23 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "type": this.type,
+            "value": this.value?.toJson(),
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "attributes": this.attributes?.map(e => e.toJson()),
+            "data": this.data,
+            "friendlyName": this.friendlyName?.toJson(),
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "aTQA": this.aTQA,
+            "bitRateR": this.bitRateR,
+            "bitRateS": this.bitRateS,
+            "chipTypeA": this.chipTypeA,
+            "mifareMemory": this.mifareMemory,
+            "rfidType": this.rfidType,
+            "sAK": this.sAK,
+            "support4": this.support4,
+            "supportMifare": this.supportMifare,
+            "aTQB": this.aTQB,
+            "aTR": this.aTR,
+            "baudrate1": this.baudrate1,
+            "baudrate2": this.baudrate2,
+            "uID": this.uID,
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+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;
+    }
+
+    toJson() {
+        return {
+            "type": this.type,
+            "extensions": this.extensions?.map(e => e.toJson()),
+            "fileName": this.fileName?.toJson(),
+            "issuer": this.issuer?.toJson(),
+            "notifications": this.notifications,
+            "origin": this.origin,
+            "paStatus": this.paStatus,
+            "serialNumber": this.serialNumber,
+            "signatureAlgorithm": this.signatureAlgorithm,
+            "subject": this.subject?.toJson(),
+            "subjectPKAlgorithm": this.subjectPKAlgorithm,
+            "validity": this.validity?.toJson(),
+            "version": this.version,
+        }
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,56 @@
+import { FileData } from "./FileData";
+import { RFIDDataFileType } from "./RFIDDataFileType";
+import { RFIDErrorCodes } from "../../rfid/RFIDErrorCodes";
+import { SecurityObjectCertificates } from "./SecurityObjectCertificates";
+
+export class File {
+    fileData
+    fileID
+    notifications
+    pAStatus
+    readingStatus
+    readingTime
+    type
+    typeName
+    docFieldsText
+    docFieldsGraphics
+    docFieldsOriginals
+    certificates
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new File();
+        result.readingTime = jsonObject["readingTime"];
+        result.type = jsonObject["type"];
+        result.typeName = jsonObject["typeName"];
+        result.pAStatus = jsonObject["pAStatus"];
+        result.readingStatus = jsonObject["readingStatus"];
+        result.fileID = jsonObject["fileID"];
+        result.fileData = FileData.fromJson(jsonObject["fileData"]);
+        result.certificates = SecurityObjectCertificates.fromJson(jsonObject["certificates"]);
+        result.notifications = jsonObject["notifications"];
+        result.docFieldsText = jsonObject["docFieldsText"];
+        result.docFieldsGraphics = jsonObject["docFieldsGraphics"];
+        result.docFieldsOriginals = jsonObject["docFieldsOriginals"];
+        
+        return result;
+    }
+
+    toJson() {
+        return {
+            "fileData": this.fileData?.toJson(),
+            "fileID": this.fileID,
+            "notifications": this.notifications,
+            "pAStatus": this.pAStatus,
+            "readingStatus": this.readingStatus,
+            "readingTime": this.readingTime,
+            "type": this.type,
+            "typeName": this.typeName,
+            "docFieldsText": this.docFieldsText,
+            "docFieldsGraphics": this.docFieldsGraphics,
+            "docFieldsOriginals": this.docFieldsOriginals,
+            "certificates": this.certificates?.toJson(),
+        }
+    }
+}

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

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