@regulaforensics/document-reader 8.4.401-beta → 8.4.507-rc

package/www/react-native/engagement/DataRetrieval.js

@@ -0,0 +1,55 @@
+import { MDLIntentToRetain } from "./NameSpaceMDL";
+import { DocumentRequestMDL } from "./DocumentRequestMDL";
+
+export class DataRetrieval {
+    deviceRetrieval
+    docRequestPreset
+    intentToRetain = MDLIntentToRetain.FALSE
+    requests = []
+
+    constructor(deviceRetrieval) {
+        this.deviceRetrieval = deviceRetrieval
+    }
+
+    setDocRequestPreset(docRequestPreset, intentToRetain) {
+        this.docRequestPreset = docRequestPreset
+        this.intentToRetain = intentToRetain
+    }
+
+    addDocRequest(request) {
+        requests.push(request);
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DataRetrieval(jsonObject["deviceRetrieval"])
+
+        result.docRequestPreset = jsonObject["docRequestPreset"]
+        result.intentToRetain = jsonObject["intentToRetain"]
+        result.requests = (jsonObject["requests"]).map(item => DocumentRequestMDL.fromJson(item));
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "deviceRetrieval": this.deviceRetrieval,
+            "docRequestPreset": this.docRequestPreset,
+            "intentToRetain": this.intentToRetain,
+            "requests": this.requests.map(item => item.toJson())
+        }
+    }
+}
+
+export const MDLDocRequestPreset = {
+    ALL: 0,
+    AGE: 1,
+    STANDARD_ID: 2,
+    TRAVEL: 3,
+    DRIVERS_LICENSE: 4,
+}
+
+export const MDLDeviceRetrieval = {
+    NFC: 1,
+    BLE: 2,
+}

package/www/react-native/engagement/DeviceEngagement.js

@@ -0,0 +1,30 @@
+import { DeviceRetrievalMethod } from "./DeviceRetrievalMethod";
+
+export class DeviceEngagement {
+    deviceRetrievalMethods = []
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DeviceEngagement()
+
+        for (var item of jsonObject["deviceRetrievalMethods"]) {
+            item = DeviceRetrievalMethod.fromJson(item);
+            if (item != null) {
+                result.deviceRetrievalMethods.push(item);
+            }
+        }
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "deviceRetrievalMethods": this.deviceRetrievalMethods.map(e => e.toJson()),
+        }
+    }
+}
+
+export const MDLDeviceEngagement = {
+    QR: 0,
+    NFC: 1,
+}

package/www/react-native/engagement/DeviceRetrievalMethod.js

@@ -0,0 +1,41 @@
+import { MDLDeviceRetrieval } from "./DataRetrieval";
+
+export class DeviceRetrievalMethod {
+    type
+    version
+    cmdMaxLength
+    respMaxLength
+    clientModeSupport
+    clientModeUUID
+    serverModeSupport
+    serverModeUUID
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DeviceRetrievalMethod()
+
+        result.type = jsonObject["type"]
+        result.version = jsonObject["version"]
+        result.cmdMaxLength = jsonObject["cmdMaxLength"]
+        result.respMaxLength = jsonObject["respMaxLength"]
+        result.clientModeSupport = jsonObject["clientModeSupport"]
+        result.clientModeUUID = jsonObject["clientModeUUID"]
+        result.serverModeSupport = jsonObject["serverModeSupport"]
+        result.serverModeUUID = jsonObject["serverModeUUID"]
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "type": this.type,
+            "version": this.version,
+            "cmdMaxLength": this.cmdMaxLength,
+            "respMaxLength": this.respMaxLength,
+            "clientModeSupport": this.clientModeSupport,
+            "clientModeUUID": this.clientModeUUID,
+            "serverModeSupport": this.serverModeSupport,
+            "serverModeUUID": this.serverModeUUID,
+        }
+    }
+}

package/www/react-native/engagement/DocumentRequestMDL.js

@@ -0,0 +1,212 @@
+import { NameSpaceMDL, MDLIntentToRetain } from "./NameSpaceMDL";
+
+export class DocumentRequestMDL {
+    docType
+    namespaces = []
+
+    constructor(docType) {
+        this.docType = docType
+    }
+
+    addNameSpace(namespace) {
+        this.namespaces.push(namespace);
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null;
+        var docType = jsonObject["docType"];
+        if (docType == "org.iso.18013.5.1.mDL") {
+            return DocumentRequest18013MDL.fromJson(jsonObject);
+        }
+        var result = new DocumentRequestMDL(docType);
+
+        result.namespaces = (jsonObject["namespaces"]).map(item => NameSpaceMDL.fromJson(item));
+
+        return result;
+    }
+
+    toJson() {
+        return {
+            "docType": this.docType,
+            "namespaces": this.namespaces.map(item => item.toJson())
+        }
+    }
+}
+
+export class DocumentRequest18013MDL extends DocumentRequestMDL {
+    familyName
+    givenName
+    birthDate
+    issueDate
+    expiryDate
+    issuingCountry
+    issuingAuthority
+    documentNumber
+    portrait
+    drivingPrivileges
+    unDistinguishingSign
+    administrativeNumber
+    sex
+    height
+    weight
+    eyeColour
+    hairColour
+    birthPlace
+    residentAddress
+    portraitCaptureDate
+    ageInYears
+    ageBirthYear
+    ageOver18
+    issuingJurisdiction
+    nationality
+    residentCity
+    residentState
+    residentPostalCode
+    residentCountry
+    biometricTemplateFace
+    biometricTemplateIris
+    biometricTemplateFinger
+    biometricTemplateSignatureSign
+    familyNameNationalCharacter
+    givenNameNationalCharacter
+    signatureUsualMark
+
+    constructor() {
+        super("org.iso.18013.5.1.mDL")
+    }
+
+    disableIntentToRetainValues() {
+        this.setAll(MDLIntentToRetain.FALSE);
+    }
+
+    enableIntentToRetainValues() {
+        this.setAll(MDLIntentToRetain.TRUE);
+    }
+
+    setAll(value) {
+        this.familyName = value;
+        this.givenName = value;
+        this.birthDate = value;
+        this.issueDate = value;
+        this.expiryDate = value;
+        this.issuingCountry = value;
+        this.issuingAuthority = value;
+        this.documentNumber = value;
+        this.portrait = value;
+        this.drivingPrivileges = value;
+        this.unDistinguishingSign = value;
+        this.administrativeNumber = value;
+        this.sex = value;
+        this.height = value;
+        this.weight = value;
+        this.eyeColour = value;
+        this.hairColour = value;
+        this.birthPlace = value;
+        this.residentAddress = value;
+        this.portraitCaptureDate = value;
+        this.ageInYears = value;
+        this.ageBirthYear = value;
+        this.ageOver18 = value;
+        this.issuingJurisdiction = value;
+        this.nationality = value;
+        this.residentCity = value;
+        this.residentState = value;
+        this.residentPostalCode = value;
+        this.residentCountry = value;
+        this.biometricTemplateFace = value;
+        this.biometricTemplateIris = value;
+        this.biometricTemplateFinger = value;
+        this.biometricTemplateSignatureSign = value;
+        this.familyNameNationalCharacter = value;
+        this.givenNameNationalCharacter = value;
+        this.signatureUsualMark = value;
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DocumentRequest18013MDL()
+
+        result.namespaces = (jsonObject["namespaces"]).map(item => NameSpaceMDL.fromJson(item));
+        result.familyName = jsonObject["familyName"]
+        result.givenName = jsonObject["givenName"]
+        result.birthDate = jsonObject["birthDate"]
+        result.issueDate = jsonObject["issueDate"]
+        result.expiryDate = jsonObject["expiryDate"]
+        result.issuingCountry = jsonObject["issuingCountry"]
+        result.issuingAuthority = jsonObject["issuingAuthority"]
+        result.documentNumber = jsonObject["documentNumber"]
+        result.portrait = jsonObject["portrait"]
+        result.drivingPrivileges = jsonObject["drivingPrivileges"]
+        result.unDistinguishingSign = jsonObject["unDistinguishingSign"]
+        result.administrativeNumber = jsonObject["administrativeNumber"]
+        result.sex = jsonObject["sex"]
+        result.height = jsonObject["height"]
+        result.weight = jsonObject["weight"]
+        result.eyeColour = jsonObject["eyeColour"]
+        result.hairColour = jsonObject["hairColour"]
+        result.birthPlace = jsonObject["birthPlace"]
+        result.residentAddress = jsonObject["residentAddress"]
+        result.portraitCaptureDate = jsonObject["portraitCaptureDate"]
+        result.ageInYears = jsonObject["ageInYears"]
+        result.ageBirthYear = jsonObject["ageBirthYear"]
+        result.ageOver18 = jsonObject["ageOver18"]
+        result.issuingJurisdiction = jsonObject["issuingJurisdiction"]
+        result.nationality = jsonObject["nationality"]
+        result.residentCity = jsonObject["residentCity"]
+        result.residentState = jsonObject["residentState"]
+        result.residentPostalCode = jsonObject["residentPostalCode"]
+        result.residentCountry = jsonObject["residentCountry"]
+        result.biometricTemplateFace = jsonObject["biometricTemplateFace"]
+        result.biometricTemplateIris = jsonObject["biometricTemplateIris"]
+        result.biometricTemplateFinger = jsonObject["biometricTemplateFinger"]
+        result.biometricTemplateSignatureSign = jsonObject["biometricTemplateSignatureSign"]
+        result.familyNameNationalCharacter = jsonObject["familyNameNationalCharacter"]
+        result.givenNameNationalCharacter = jsonObject["givenNameNationalCharacter"]
+        result.signatureUsualMark = jsonObject["signatureUsualMark"]
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "docType": this.docType,
+            "namespaces": this.namespaces.map(item => item.toJson()),
+            "familyName": this.familyName,
+            "givenName": this.givenName,
+            "birthDate": this.birthDate,
+            "issueDate": this.issueDate,
+            "expiryDate": this.expiryDate,
+            "issuingCountry": this.issuingCountry,
+            "issuingAuthority": this.issuingAuthority,
+            "documentNumber": this.documentNumber,
+            "portrait": this.portrait,
+            "drivingPrivileges": this.drivingPrivileges,
+            "unDistinguishingSign": this.unDistinguishingSign,
+            "administrativeNumber": this.administrativeNumber,
+            "sex": this.sex,
+            "height": this.height,
+            "weight": this.weight,
+            "eyeColour": this.eyeColour,
+            "hairColour": this.hairColour,
+            "birthPlace": this.birthPlace,
+            "residentAddress": this.residentAddress,
+            "portraitCaptureDate": this.portraitCaptureDate,
+            "ageInYears": this.ageInYears,
+            "ageBirthYear": this.ageBirthYear,
+            "ageOver18": this.ageOver18,
+            "issuingJurisdiction": this.issuingJurisdiction,
+            "nationality": this.nationality,
+            "residentCity": this.residentCity,
+            "residentState": this.residentState,
+            "residentPostalCode": this.residentPostalCode,
+            "residentCountry": this.residentCountry,
+            "biometricTemplateFace": this.biometricTemplateFace,
+            "biometricTemplateIris": this.biometricTemplateIris,
+            "biometricTemplateFinger": this.biometricTemplateFinger,
+            "biometricTemplateSignatureSign": this.biometricTemplateSignatureSign,
+            "familyNameNationalCharacter": this.familyNameNationalCharacter,
+            "givenNameNationalCharacter": this.givenNameNationalCharacter,
+            "signatureUsualMark": this.signatureUsualMark,
+        }
+    }
+}

package/www/react-native/engagement/NameSpaceMDL.js

@@ -0,0 +1,33 @@
+export class NameSpaceMDL {
+    name
+    map = {}
+
+    constructor(name) {
+        this.name = name
+    }
+
+    addField(name, intentToRetain) {
+        this.map[name] = intentToRetain;
+      }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new NameSpaceMDL(jsonObject["name"])
+
+        result.map = jsonObject["map"]
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "name": this.name,
+            "map": this.map
+        }
+    }
+}
+
+export const MDLIntentToRetain = {
+    FALSE: 0,
+    TRUE: 1,
+}

package/www/react-native/index.js

@@ -43,8 +43,9 @@ import { RFIDStatus } from './results/status/RFIDStatus';
 import { ResultsStatus } from './results/status/ResultsStatus';
 import { CheckResult } from './results/status/CheckResult';
 import { OpticalStatus } from './results/status/OpticalStatus';
+import { AgeStatus } from './results/status/AgeStatus';
 import { ProcessingFinishedStatus } from './results/Results';
-export { RFIDStatus, ResultsStatus, CheckResult, OpticalStatus, ProcessingFinishedStatus };
+export { RFIDStatus, ResultsStatus, CheckResult, OpticalStatus, AgeStatus, ProcessingFinishedStatus };
 
 import { CheckDiagnose } from './results/authenticity/CheckDiagnose';
 import { AuthenticityElement } from './results/authenticity/AuthenticityElement';
@@ -69,8 +70,10 @@ export { ImageQuality, ImageQualityGroup, ImageQualityCheckType };
 import { LDSParsingErrorCodes } from './results/visible_digital_seals/LDSParsingErrorCodes';
 import { VDSNCData } from './results/visible_digital_seals/VDSNCData';
 import { BytesData } from './results/visible_digital_seals/BytesData';
+import { DocFeature } from './results/visible_digital_seals/DocFeature';
+import { VDSData } from './results/visible_digital_seals/VDSData';
 import { LDSParsingNotificationCodes } from './results/visible_digital_seals/LDSParsingNotificationCodes';
-export { LDSParsingErrorCodes, VDSNCData, BytesData, LDSParsingNotificationCodes };
+export { LDSParsingErrorCodes, VDSNCData, BytesData, DocFeature, VDSData, LDSParsingNotificationCodes };
 
 import { SecurityObject } from './results/rfid/SecurityObject';
 import { CardProperties } from './results/rfid/CardProperties';
@@ -94,17 +97,16 @@ import { Extension } from './results/rfid/Extension';
 import { AccessControlProcedureType } from './results/rfid/AccessControlProcedureType';
 export { SecurityObject, CardProperties, DataField, Attribute, SignerInfo, SecurityObjectCertificates, CertificateChain, Authority, File, RFIDValue, RFIDValidity, RFIDDataFileType, CertificateData, FileData, RFIDCertificateType, RFIDSessionData, Application, RFIDApplicationType, RFIDAccessControlProcedureType, Extension, AccessControlProcedureType };
 
-import { FilterObject, FilterObjectType } from './params/process_params/FilterObject';
-import { LivenessParams, LivenessCheckType } from './params/process_params/LivenessParams';
-import { ProcessParams, MeasureSystem, MRZFormat, LogLevel, MrzDetectionModes, FilterCheckType } from './params/process_params/ProcessParams';
+import { LivenessParams } from './params/process_params/LivenessParams';
+import { ProcessParams, MeasureSystem, MRZFormat, LogLevel, MrzDetectionModes } from './params/process_params/ProcessParams';
 import { GlaresCheckParams } from './params/process_params/GlaresCheckParams';
 import { FaceApiParams } from './params/process_params/FaceApiParams';
 import { RFIDParams } from './params/process_params/RFIDParams';
 import { ImageQA } from './params/process_params/ImageQA';
-import { AuthenticityParams, AuthenticityCheckType } from './params/process_params/AuthenticityParams';
+import { AuthenticityParams } from './params/process_params/AuthenticityParams';
 import { BackendProcessingConfig } from './params/process_params/BackendProcessingConfig';
 import { FaceApiSearchParams } from './params/process_params/FaceApiSearchParams';
-export { FilterObject, FilterObjectType, LivenessParams, LivenessCheckType, ProcessParams, MeasureSystem, MRZFormat, LogLevel, MrzDetectionModes, FilterCheckType, GlaresCheckParams, FaceApiParams, RFIDParams, ImageQA, AuthenticityParams, AuthenticityCheckType, BackendProcessingConfig, FaceApiSearchParams };
+export { LivenessParams, ProcessParams, MeasureSystem, MRZFormat, LogLevel, MrzDetectionModes, GlaresCheckParams, FaceApiParams, RFIDParams, ImageQA, AuthenticityParams, BackendProcessingConfig, FaceApiSearchParams };
 
 import { Functionality, CameraPosition, CaptureMode, CameraMode, CaptureSessionPreset, DocReaderFrame, CameraSize } from './params/Functionality';
 export { Functionality, CameraPosition, CaptureMode, CameraMode, CaptureSessionPreset, DocReaderFrame, CameraSize };
@@ -132,6 +134,13 @@ import { TAChallenge } from './rfid/TAChallenge';
 import { PKDCertificate, PKDResourceType } from './rfid/PKDCertificate';
 export { PAResourcesIssuer, RFIDErrorCodes, TccParams, RFIDNotification, RFIDNotificationCodes, PAAttribute, TAChallenge, PKDCertificate, PKDResourceType };
 
+import { DataRetrieval, MDLDocRequestPreset, MDLDeviceRetrieval } from './engagement/DataRetrieval';
+import { DeviceEngagement, MDLDeviceEngagement } from './engagement/DeviceEngagement';
+import { NameSpaceMDL, MDLIntentToRetain } from './engagement/NameSpaceMDL';
+import { DocumentRequestMDL, DocumentRequest18013MDL } from './engagement/DocumentRequestMDL';
+import { DeviceRetrievalMethod } from './engagement/DeviceRetrievalMethod';
+export { DataRetrieval, MDLDocRequestPreset, MDLDeviceRetrieval, DeviceEngagement, MDLDeviceEngagement, DeviceRetrievalMethod, DocumentRequest18013MDL, MDLIntentToRetain, NameSpaceMDL, DocumentRequestMDL };
+
 export class DocumentReader {
     static get instance() { return DocumentReader._instance }
     static _instance = new DocumentReader()
@@ -372,6 +381,48 @@ export class DocumentReader {
         exec("endBackendTransaction", []);
     }
 
+    async readMDL(type, retrieval) {
+        var response = await exec("startReadMDl", [type, retrieval.toJson()]);
+        var jsonObject = JSON.parse(response);
+        return [
+            jsonObject["action"],
+            Results.fromJson(jsonObject["results"]),
+            DocReaderException.fromJson(jsonObject["error"]),
+        ]
+    }
+
+    async engageDevice(type, options) {
+        var response = "";
+        if (options?.withoutUI != true) {
+            response = await exec("startEngageDevice", [type.value]);
+          } else if (type == MDLDeviceEngagement.NFC) {
+            response = await exec("engageDeviceNFC", []);
+          } else if (type == MDLDeviceEngagement.QR && options?.data != null) {
+            response = await exec("engageDeviceData", [options.data]);
+          }
+
+        var jsonObject = JSON.parse(response);
+        return [
+            DeviceEngagement.fromJson(jsonObject["deviceEngagement"]),
+            DocReaderException.fromJson(jsonObject["error"]),
+        ]
+    }
+
+    async retrieveData(retrieval, options) {
+        var func = "startRetrieveData";
+        if (options?.withoutUI == MDLDeviceRetrieval.NFC) func = "engageDeviceNFC";
+        if (options?.withoutUI == MDLDeviceRetrieval.BLE) func = "engageDeviceBLE";
+        
+        var response = await exec(func, [retrieval.toJson(), options?.engagement?.toJson()]);
+        var jsonObject = JSON.parse(response);
+
+        return [
+            jsonObject["action"],
+            Results.fromJson(jsonObject["results"]),
+            DocReaderException.fromJson(jsonObject["error"]),
+        ]
+    }
+
     _successOrErrorFromJson(jsonString) {
         var jsonObject = JSON.parse(jsonString);
         var success = jsonObject["success"];

package/www/react-native/info/DocReaderException.js

@@ -53,6 +53,7 @@ export const ErrorCodes = {
     CAMERA_NO_PERMISSION: 29,
     CAMERA_NOT_AVAILABLE: 30,
     CANNOT_USE_CAMERA_IN_SCENARIO: 40,
+    BLUETOOTH_NO_PERMISSION: 41,
     BACKEND_ONLINE_PROCESSING: 303,
     WRONG_INPUT: 400,
     RESULT_UNAVAILABLE: 410,
@@ -62,5 +63,6 @@ export const ErrorCodes = {
     FEATURE_BLUETOOTH_LE_NOT_SUPPORTED: 601,
     APP_BACKGROUND: 700,
     ONLINE_PROCESSING_WRONG_INPUT: 800,
+    MDL_EXCEPTION: 900,
     NATIVE_JAVA_EXCEPTION: 1000
 }

package/www/react-native/params/Functionality.js

@@ -111,6 +111,12 @@ export class Functionality {
         this._set({ "preventScreenRecording": val });
     }
 
+    get homeIndicatorAutoHide() { return this._homeIndicatorAutoHide; }
+    set homeIndicatorAutoHide(val) {
+        this._homeIndicatorAutoHide = val;
+        this._set({ "homeIndicatorAutoHide": val });
+    }
+
     get showCaptureButtonDelayFromDetect() { return this._showCaptureButtonDelayFromDetect; }
     set showCaptureButtonDelayFromDetect(val) {
         this._showCaptureButtonDelayFromDetect = val;
@@ -189,6 +195,12 @@ export class Functionality {
         this._set({ "videoRecordingSizeDownscaleFactor": val });
     }
 
+    get mdlTimeout() { return this._mdlTimeout; }
+    set mdlTimeout(val) {
+        this._mdlTimeout = val;
+        this._set({ "mdlTimeout": val });
+    }
+
     get excludedCamera2Models() { return this._excludedCamera2Models; }
     set excludedCamera2Models(val) {
         this._excludedCamera2Models = val;
@@ -229,6 +241,7 @@ export class Functionality {
         result._singleResult = jsonObject["singleResult"];
         result._torchTurnedOn = jsonObject["torchTurnedOn"];
         result._preventScreenRecording = jsonObject["preventScreenRecording"];
+        result._homeIndicatorAutoHide = jsonObject["homeIndicatorAutoHide"];
         result._showCaptureButtonDelayFromDetect = jsonObject["showCaptureButtonDelayFromDetect"];
         result._showCaptureButtonDelayFromStart = jsonObject["showCaptureButtonDelayFromStart"];
         result._rfidTimeout = jsonObject["rfidTimeout"];
@@ -242,6 +255,7 @@ export class Functionality {
         result._zoomFactor = jsonObject["zoomFactor"];
         result._exposure = jsonObject["exposure"];
         result._videoRecordingSizeDownscaleFactor = jsonObject["videoRecordingSizeDownscaleFactor"];
+        result._mdlTimeout = jsonObject["mdlTimeout"];
         result._excludedCamera2Models = jsonObject["excludedCamera2Models"];
         result._cameraResolutionAndroid = CameraSize.fromJson(jsonObject["cameraSize"]);
         result._cameraResolutionIOS = jsonObject["videoSessionPreset"];
@@ -269,6 +283,7 @@ export class Functionality {
             "singleResult": this.singleResult,
             "torchTurnedOn": this.torchTurnedOn,
             "preventScreenRecording": this.preventScreenRecording,
+            "homeIndicatorAutoHide": this.homeIndicatorAutoHide,
             "showCaptureButtonDelayFromDetect": this.showCaptureButtonDelayFromDetect,
             "showCaptureButtonDelayFromStart": this.showCaptureButtonDelayFromStart,
             "rfidTimeout": this.rfidTimeout,
@@ -282,6 +297,7 @@ export class Functionality {
             "zoomFactor": this.zoomFactor,
             "exposure": this.exposure,
             "videoRecordingSizeDownscaleFactor": this.videoRecordingSizeDownscaleFactor,
+            "mdlTimeout": this.mdlTimeout,
             "excludedCamera2Models": this.excludedCamera2Models,
             "cameraSize": this.cameraResolutionAndroid?.toJson(),
             "videoSessionPreset": this.cameraResolutionIOS,

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

@@ -240,6 +240,12 @@ export class Customization {
         this._set({ "cameraPreviewVerticalPositionMultiplier": val });
     }
 
+    get multipageButtonPositionMultiplier() { return this._multipageButtonPositionMultiplier; }
+    set multipageButtonPositionMultiplier(val) {
+        this._multipageButtonPositionMultiplier = val;
+        this._set({ "multipageButtonPositionMultiplier": val });
+    }
+
     get multipageAnimationFrontImage() { return this._multipageAnimationFrontImage; }
     set multipageAnimationFrontImage(val) {
         this._multipageAnimationFrontImage = val;
@@ -476,6 +482,7 @@ export class Customization {
         result._activityIndicatorPortraitPositionMultiplier = jsonObject["activityIndicatorPortraitPositionMultiplier"];
         result._activityIndicatorLandscapePositionMultiplier = jsonObject["activityIndicatorLandscapePositionMultiplier"];
         result._cameraPreviewVerticalPositionMultiplier = jsonObject["cameraPreviewVerticalPositionMultiplier"];
+        result._multipageButtonPositionMultiplier = jsonObject["multipageButtonPositionMultiplier"];
         result._multipageAnimationFrontImage = jsonObject["multipageAnimationFrontImage"];
         result._multipageAnimationBackImage = jsonObject["multipageAnimationBackImage"];
         result._borderBackgroundImage = jsonObject["borderBackgroundImage"];
@@ -554,6 +561,7 @@ export class Customization {
             "activityIndicatorPortraitPositionMultiplier": this.activityIndicatorPortraitPositionMultiplier,
             "activityIndicatorLandscapePositionMultiplier": this.activityIndicatorLandscapePositionMultiplier,
             "cameraPreviewVerticalPositionMultiplier": this.cameraPreviewVerticalPositionMultiplier,
+            "multipageButtonPositionMultiplier": this.multipageButtonPositionMultiplier,
             "multipageAnimationFrontImage": this.multipageAnimationFrontImage,
             "multipageAnimationBackImage": this.multipageAnimationBackImage,
             "borderBackgroundImage": this.borderBackgroundImage,

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

@@ -1,6 +1,5 @@
 import { DocumentReader } from '../../index';
 import { LivenessParams } from './LivenessParams';
-import { FilterObject } from './FilterObject';
 
 export class AuthenticityParams {
     get useLivenessCheck() { return this._useLivenessCheck; }
@@ -9,6 +8,7 @@ export class AuthenticityParams {
         this._set({ "useLivenessCheck": val });
     }
 
+    _livenessParams = new LivenessParams();
     get livenessParams() { return this._livenessParams; }
     set livenessParams(val) { (this._livenessParams = val)._apply(); }
 
@@ -96,28 +96,6 @@ export class AuthenticityParams {
         this._set({ "checkSecurityText": val });
     }
 
-    _checkFilters = {};
-
-    setCheckFilter(checkType, filter) {
-        this._checkFilters[checkType] = filter;
-        this._set({
-            "setCheckFilter": {
-                "checkType": checkType,
-                "filterObject": filter.toJson(),
-            },
-        });
-    }
-
-    removeCheckFilter(checkType) {
-        delete this._checkFilters[checkType];
-        this._set({ "removeCheckFilter": checkType });
-    }
-
-    clearCheckFilter() {
-        this._checkFilters = {};
-        this._set({ "clearCheckFilter": null });
-    }
-
     static fromJson(jsonObject) {
         if (jsonObject == null) return new AuthenticityParams();
 
@@ -139,8 +117,6 @@ export class AuthenticityParams {
         result._checkPhotoComparison = jsonObject["checkPhotoComparison"];
         result._checkLetterScreen = jsonObject["checkLetterScreen"];
         result._checkSecurityText = jsonObject["checkSecurityText"];
-        result._checkFilters = Object.fromEntries(Object.entries(jsonObject["checkFilters"] ?? {})
-            .map(([k, v]) => [k, FilterObject.fromJson(v)]));
 
         return result;
     }
@@ -170,25 +146,6 @@ export class AuthenticityParams {
             "checkPhotoComparison": this.checkPhotoComparison,
             "checkLetterScreen": this.checkLetterScreen,
             "checkSecurityText": this.checkSecurityText,
-            "checkFilters": Object.fromEntries(Object.entries(this._checkFilters).map(([k, v]) => [k, v.toJson()])),
         }
     }
 }
-
-export const AuthenticityCheckType = {
-    USE_LIVENESS: "checkLiveness",
-    UV_LUMINISCENCE: "checkUVLuminiscence",
-    IR_B900: "checkIRB900",
-    IMAGE_PATTERNS: "checkImagePatterns",
-    FIBERS: "checkFibers",
-    EXT_MRZ: "checkExtMRZ",
-    EXT_OCR: "checkExtOCR",
-    AXIAL: "checkAxial",
-    BARCODE_FORMAT: "checkBarcodeFormat",
-    IR_VISIBILITY: "checkIRVisibility",
-    IPI: "checkIPI",
-    PHOTO_EMBEDDING: "checkPhotoEmbedding",
-    PHOTO_COMPARISON: "checkPhotoComparison",
-    LETTER_SCREEN: "checkLetterScreen",
-    SECURITY_TEXT: "checkSecurityText",
-};