@regulaforensics/document-reader 8.2.186-beta

package/www/react-native/params/customization/Font.js

@@ -0,0 +1,28 @@
+export class Font {
+    name
+    size
+    style
+
+    constructor(name, options) {
+        this.name = name;
+        this.size = options?.size;
+        this.style = options?.style;
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+
+        const result = new Font(jsonObject["name"]);
+        result.size = jsonObject["size"];
+        result.style = jsonObject["style"];
+
+        return result;
+    }
+}
+
+export const FontStyle = {
+    NORMAL: 0,
+    BOLD: 1,
+    ITALIC: 2,
+    BOLD_ITALIC: 3
+};

package/www/react-native/params/process_params/AuthenticityParams.js

@@ -0,0 +1,129 @@
+import { DocumentReader } from '../../index';
+import { LivenessParams } from './LivenessParams';
+
+export class AuthenticityParams {
+    get useLivenessCheck() { return this._useLivenessCheck; }
+    set useLivenessCheck(val) {
+        this._useLivenessCheck = val;
+        this._set({ "useLivenessCheck": val });
+    }
+
+    get livenessParams() { return this._livenessParams; }
+    set livenessParams(val) { (this._livenessParams = val)._apply(); }
+
+    get checkUVLuminiscence() { return this._checkUVLuminiscence; }
+    set checkUVLuminiscence(val) {
+        this._checkUVLuminiscence = val;
+        this._set({ "checkUVLuminiscence": val });
+    }
+
+    get checkIRB900() { return this._checkIRB900; }
+    set checkIRB900(val) {
+        this._checkIRB900 = val;
+        this._set({ "checkIRB900": val });
+    }
+
+    get checkImagePatterns() { return this._checkImagePatterns; }
+    set checkImagePatterns(val) {
+        this._checkImagePatterns = val;
+        this._set({ "checkImagePatterns": val });
+    }
+
+    get checkFibers() { return this._checkFibers; }
+    set checkFibers(val) {
+        this._checkFibers = val;
+        this._set({ "checkFibers": val });
+    }
+
+    get checkExtMRZ() { return this._checkExtMRZ; }
+    set checkExtMRZ(val) {
+        this._checkExtMRZ = val;
+        this._set({ "checkExtMRZ": val });
+    }
+
+    get checkExtOCR() { return this._checkExtOCR; }
+    set checkExtOCR(val) {
+        this._checkExtOCR = val;
+        this._set({ "checkExtOCR": val });
+    }
+
+    get checkAxial() { return this._checkAxial; }
+    set checkAxial(val) {
+        this._checkAxial = val;
+        this._set({ "checkAxial": val });
+    }
+
+    get checkBarcodeFormat() { return this._checkBarcodeFormat; }
+    set checkBarcodeFormat(val) {
+        this._checkBarcodeFormat = val;
+        this._set({ "checkBarcodeFormat": val });
+    }
+
+    get checkIRVisibility() { return this._checkIRVisibility; }
+    set checkIRVisibility(val) {
+        this._checkIRVisibility = val;
+        this._set({ "checkIRVisibility": val });
+    }
+
+    get checkIPI() { return this._checkIPI; }
+    set checkIPI(val) {
+        this._checkIPI = val;
+        this._set({ "checkIPI": val });
+    }
+
+    get checkPhotoEmbedding() { return this._checkPhotoEmbedding; }
+    set checkPhotoEmbedding(val) {
+        this._checkPhotoEmbedding = val;
+        this._set({ "checkPhotoEmbedding": val });
+    }
+
+    get checkPhotoComparison() { return this._checkPhotoComparison; }
+    set checkPhotoComparison(val) {
+        this._checkPhotoComparison = val;
+        this._set({ "checkPhotoComparison": val });
+    }
+
+    get checkLetterScreen() { return this._checkLetterScreen; }
+    set checkLetterScreen(val) {
+        this._checkLetterScreen = val;
+        this._set({ "checkLetterScreen": val });
+    }
+
+    get checkSecurityText() { return this._checkSecurityText; }
+    set checkSecurityText(val) {
+        this._checkSecurityText = val;
+        this._set({ "checkSecurityText": val });
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return new AuthenticityParams();
+
+        const result = new AuthenticityParams();
+
+        result._useLivenessCheck = jsonObject["useLivenessCheck"];
+        result._livenessParams = LivenessParams.fromJson(jsonObject["livenessParams"]);
+        result._checkUVLuminiscence = jsonObject["checkUVLuminiscence"];
+        result._checkIRB900 = jsonObject["checkIRB900"];
+        result._checkImagePatterns = jsonObject["checkImagePatterns"];
+        result._checkFibers = jsonObject["checkFibers"];
+        result._checkExtMRZ = jsonObject["checkExtMRZ"];
+        result._checkExtOCR = jsonObject["checkExtOCR"];
+        result._checkAxial = jsonObject["checkAxial"];
+        result._checkBarcodeFormat = jsonObject["checkBarcodeFormat"];
+        result._checkIRVisibility = jsonObject["checkIRVisibility"];
+        result._checkIPI = jsonObject["checkIPI"];
+        result._checkPhotoEmbedding = jsonObject["checkPhotoEmbedding"];
+        result._checkPhotoComparison = jsonObject["checkPhotoComparison"];
+        result._checkLetterScreen = jsonObject["checkLetterScreen"];
+        result._checkSecurityText = jsonObject["checkSecurityText"];
+
+        return result;
+    }
+
+    _apply() { this._set(this); }
+    _set(json) {
+        const parentJson = { "authenticityParams": json };
+        const parent = DocumentReader.instance.processParams;
+        if (this === parent.authenticityParams) parent._set(parentJson);
+    }
+}

package/www/react-native/params/process_params/BackendProcessingConfig.js

@@ -0,0 +1,25 @@
+export class BackendProcessingConfig {
+    url
+    httpHeaders
+    rfidServerSideChipVerification
+    timeoutConnection
+
+    constructor(url, options) {
+        this.url = url;
+        this.rfidServerSideChipVerification = options?.rfidServerSideChipVerification;
+        this.httpHeaders = options?.httpHeaders;
+        this.timeoutConnection = options?.timeoutConnection;
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new BackendProcessingConfig(jsonObject["url"]);
+        
+        result.rfidServerSideChipVerification = jsonObject["rfidServerSideChipVerification"];
+        result.httpHeaders = jsonObject["httpHeaders"];
+        result.timeoutConnection = jsonObject["timeoutConnection"];
+        
+        return result;
+    }
+}

package/www/react-native/params/process_params/FaceApiParams.js

@@ -0,0 +1,38 @@
+import { FaceApiSearchParams } from "./FaceApiSearchParams";
+
+export class FaceApiParams {
+    url
+    mode
+    threshold
+    searchParams
+    serviceTimeout
+    proxy
+    proxyPassword
+    proxyType
+
+    constructor(options) {
+        this.url = options?.url ?? "https://faceapi.regulaforensics.com";
+        this.mode = options?.mode ?? "match";
+        this.threshold = options?.threshold ?? 75;
+        this.searchParams = options?.searchParams;
+        this.serviceTimeout = options?.serviceTimeout ?? 3000;
+        this.proxy = options?.proxy;
+        this.proxyPassword = options?.proxyPassword;
+        this.proxyType = options?.proxyType;
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        return new FaceApiParams({
+            url: jsonObject["url"],
+            mode: jsonObject["mode"],
+            threshold: jsonObject["threshold"],
+            searchParams: FaceApiSearchParams.fromJson(jsonObject["searchParams"]),
+            serviceTimeout: jsonObject["serviceTimeout"],
+            proxy: jsonObject["proxy"],
+            proxyPassword: jsonObject["proxyPassword"],
+            proxyType: jsonObject["proxyType"]
+        });
+    }
+}

package/www/react-native/params/process_params/FaceApiSearchParams.js

@@ -0,0 +1,21 @@
+export class FaceApiSearchParams {
+    limit
+    threshold
+    groupIds
+
+    constructor(options) {
+        this.limit = options?.limit ?? 100;
+        this.threshold = options?.threshold ?? 1;
+        this.groupIds = options?.groupIds;
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        return new FaceApiSearchParams({
+            limit: jsonObject["limit"],
+            threshold: jsonObject["threshold"],
+            groupIds: jsonObject["groupIds"]
+        });
+    }
+}

package/www/react-native/params/process_params/GlaresCheckParams.js

@@ -0,0 +1,18 @@
+export class GlaresCheckParams {
+    imgMarginPart
+    maxGlaringPart
+
+    constructor(options) {
+        this.imgMarginPart = options?.imgMarginPart;
+        this.maxGlaringPart = options?.maxGlaringPart;
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        return new GlaresCheckParams({
+            imgMarginPart: jsonObject["imgMarginPart"],
+            maxGlaringPart: jsonObject["maxGlaringPart"]
+        });
+    }
+}

package/www/react-native/params/process_params/ImageQA.js

@@ -0,0 +1,97 @@
+import { DocumentReader } from '../../index';
+import { GlaresCheckParams } from './GlaresCheckParams';
+import { ImageQualityCheckType } from '../../results/image_quality/ImageQualityCheckType';
+
+export class ImageQA {
+    get dpiThreshold() { return this._dpiThreshold; }
+    set dpiThreshold(val) {
+        this._dpiThreshold = val;
+        this._set({ "dpiThreshold": val });
+    }
+
+    get angleThreshold() { return this._angleThreshold; }
+    set angleThreshold(val) {
+        this._angleThreshold = val;
+        this._set({ "angleThreshold": val });
+    }
+
+    get focusCheck() { return this._focusCheck; }
+    set focusCheck(val) {
+        this._focusCheck = val;
+        this._set({ "focusCheck": val });
+    }
+
+    get glaresCheck() { return this._glaresCheck; }
+    set glaresCheck(val) {
+        this._glaresCheck = val;
+        this._set({ "glaresCheck": val });
+    }
+
+    get glaresCheckParams() { return this._glaresCheckParams; }
+    set glaresCheckParams(val) {
+        this._glaresCheckParams = val;
+        this._set({ "glaresCheckParams": val });
+    }
+
+    get colornessCheck() { return this._colornessCheck; }
+    set colornessCheck(val) {
+        this._colornessCheck = val;
+        this._set({ "colornessCheck": val });
+    }
+
+    get screenCapture() { return this._screenCapture; }
+    set screenCapture(val) {
+        this._screenCapture = val;
+        this._set({ "screenCapture": val });
+    }
+
+    get expectedPass() { return this._expectedPass; }
+    set expectedPass(val) {
+        this._expectedPass = val;
+        this._set({ "expectedPass": val });
+    }
+
+    get documentPositionIndent() { return this._documentPositionIndent; }
+    set documentPositionIndent(val) {
+        this._documentPositionIndent = val;
+        this._set({ "documentPositionIndent": val });
+    }
+
+    get brightnessThreshold() { return this._brightnessThreshold; }
+    set brightnessThreshold(val) {
+        this._brightnessThreshold = val;
+        this._set({ "brightnessThreshold": val });
+    }
+
+    get occlusionCheck() { return this._occlusionCheck; }
+    set occlusionCheck(val) {
+        this._occlusionCheck = val;
+        this._set({ "occlusionCheck": val });
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        
+        const result = new ImageQA();
+        result._dpiThreshold = jsonObject["dpiThreshold"];
+        result._angleThreshold = jsonObject["angleThreshold"];
+        result._focusCheck = jsonObject["focusCheck"];
+        result._glaresCheck = jsonObject["glaresCheck"];
+        result._colornessCheck = jsonObject["colornessCheck"];
+        result._screenCapture = jsonObject["screenCapture"];
+        result._expectedPass = jsonObject["expectedPass"];
+        result._glaresCheckParams = GlaresCheckParams.fromJson(jsonObject["glaresCheckParams"]);
+        result._documentPositionIndent = jsonObject["documentPositionIndent"];
+        result._brightnessThreshold = jsonObject["brightnessThreshold"];
+        result._occlusionCheck = jsonObject["occlusionCheck"];
+        
+        return result;
+    }
+
+    _apply() { this._set(this); }
+    _set(json) {
+        const parentJson = { "imageQA": json };
+        var parent = DocumentReader.instance.processParams;
+        if (this === parent.imageQA) parent._set(parentJson);
+    }
+}

package/www/react-native/params/process_params/LivenessParams.js

@@ -0,0 +1,67 @@
+import { DocumentReader } from '../../index';
+
+export class LivenessParams {
+    get checkOVI() { return this._checkOVI; }
+    set checkOVI(val) {
+        this._checkOVI = val;
+        this._set({ "checkOVI": val });
+    }
+
+    get checkMLI() { return this._checkMLI; }
+    set checkMLI(val) {
+        this._checkMLI = val;
+        this._set({ "checkMLI": val });
+    }
+
+    get checkHolo() { return this._checkHolo; }
+    set checkHolo(val) {
+        this._checkHolo = val;
+        this._set({ "checkHolo": val });
+    }
+
+    get checkED() { return this._checkED; }
+    set checkED(val) {
+        this._checkED = val;
+        this._set({ "checkED": val });
+    }
+
+    get checkBlackAndWhiteCopy() { return this._checkBlackAndWhiteCopy; }
+    set checkBlackAndWhiteCopy(val) {
+        this._checkBlackAndWhiteCopy = val;
+        this._set({ "checkBlackAndWhiteCopy": val });
+    }
+
+    get checkDynaprint() { return this._checkDynaprint; }
+    set checkDynaprint(val) {
+        this._checkDynaprint = val;
+        this._set({ "checkDynaprint": val });
+    }
+
+    get checkGeometry() { return this._checkGeometry; }
+    set checkGeometry(val) {
+        this._checkGeometry = val;
+        this._set({ "checkGeometry": val });
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return new LivenessParams();
+        
+        const result = new LivenessParams();
+        result._checkOVI = jsonObject["checkOVI"];
+        result._checkMLI = jsonObject["checkMLI"];
+        result._checkHolo = jsonObject["checkHolo"];
+        result._checkED = jsonObject["checkED"];
+        result._checkBlackAndWhiteCopy = jsonObject["checkBlackAndWhiteCopy"];
+        result._checkDynaprint = jsonObject["checkDynaprint"];
+        result._checkGeometry = jsonObject["checkGeometry"];
+        
+        return result;
+    }
+
+    _apply() { this._set(this); }
+    _set(json) {
+        const parentJson = { "livenessParams": json };
+        var parent = DocumentReader.instance.processParams.authenticityParams;
+        if (this === parent.livenessParams) parent._set(parentJson);
+    }
+}