@regulaforensics/document-reader 7.1.301-rc

package/www/capacitor/index.js

@@ -0,0 +1,502 @@
+import { exec, _setDocumentReaderCompletion, _setRFIDCompletion, _setDocumentReaderPrepareCompletion, _setCustomButtonTappedCompletion, _setVideoEncoderCompletion, _setRFIDProgressCompletion, _setChipDetectedCompletion, _setRetryReadChipCompletion, _setPaCertificateCompletion, _setTaCertificateCompletion, _setTaSignatureCompletion } from './internal/bridge'
+
+import { OnlineProcessingConfig, ImageFormat, OnlineMode } from './config/OnlineProcessingConfig';
+import { InitConfig } from './config/InitConfig';
+import { RFIDConfig } from './config/RFIDConfig';
+import { ScannerConfig } from './config/ScannerConfig';
+import { RecognizeConfig, ImageInputData } from './config/RecognizeConfig';
+export { OnlineProcessingConfig, ImageFormat, OnlineMode, InitConfig, RFIDConfig, ScannerConfig, RecognizeConfig, ImageInputData };
+
+import { DocReaderVersion } from './info/DocReaderVersion';
+import { PrepareProgress } from './info/PrepareProgress';
+import { DocReaderException, ErrorCodes } from './info/DocReaderException';
+import { DocumentsDatabase } from './info/DocumentsDatabase';
+import { License } from './info/License';
+import { DocReaderScenario, Scenario, DocReaderOrientation } from './info/DocReaderScenario';
+import { RFIDException } from './info/RFIDException';
+export { DocReaderVersion, PrepareProgress, DocReaderException, ErrorCodes, DocumentsDatabase, License, DocReaderScenario, Scenario, DocReaderOrientation, RFIDException };
+
+import { LCID } from './results/visual_results/LCID';
+import { GraphicFieldType } from './results/visual_results/GraphicFieldType';
+import { Value } from './results/visual_results/Value';
+import { Rect } from './results/visual_results/Rect';
+import { Symbol } from './results/visual_results/Symbol';
+import { Comparison } from './results/visual_results/Comparison';
+import { TextField } from './results/visual_results/TextField';
+import { Lights } from './results/visual_results/Lights';
+import { Validity } from './results/visual_results/Validity';
+import { FieldType } from './results/visual_results/FieldType';
+import { GraphicField } from './results/visual_results/GraphicField';
+import { RFIDOrigin } from './results/visual_results/RFIDOrigin';
+import { TextResult } from './results/visual_results/TextResult';
+import { TextSource } from './results/visual_results/TextSource';
+import { GraphicResult } from './results/visual_results/GraphicResult';
+export { LCID, GraphicFieldType, Value, Rect, Symbol, Comparison, TextField, Lights, Validity, FieldType, GraphicField, RFIDOrigin, TextResult, TextSource, GraphicResult };
+
+import { DocumentType, DocFormat, DocType as DocumentTypeEnum } from './results/DocumentType';
+import { Results, ResultType } from './results/Results';
+import { TransactionInfo } from './results/TransactionInfo';
+import { Position, Coordinate } from './results/Position';
+export { DocumentType, DocFormat, DocumentTypeEnum, Results, ResultType, TransactionInfo, Position, Coordinate };
+
+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 { ProcessingFinishedStatus } from './results/Results';
+export { RFIDStatus, ResultsStatus, CheckResult, OpticalStatus, ProcessingFinishedStatus };
+
+import { CheckDiagnose } from './results/authenticity/CheckDiagnose';
+import { AuthenticityElement } from './results/authenticity/AuthenticityElement';
+import { AuthenticityResult } from './results/authenticity/AuthenticityResult';
+import { AuthenticityCheck } from './results/authenticity/AuthenticityCheck';
+import { SecurityFeatureType } from './results/authenticity/SecurityFeatureType';
+import { Authenticity } from './results/authenticity/Authenticity';
+export { CheckDiagnose, AuthenticityElement, AuthenticityResult, AuthenticityCheck, SecurityFeatureType, Authenticity };
+
+import { PDF417Info } from './results/barcode/PDF417Info';
+import { BarcodeStatus } from './results/barcode/BarcodeStatus';
+import { BarcodeType } from './results/barcode/BarcodeType';
+import { BarcodeResult } from './results/barcode/BarcodeResult';
+import { BarcodeField } from './results/barcode/BarcodeField';
+export { PDF417Info, BarcodeStatus, BarcodeType, BarcodeResult, BarcodeField };
+
+import { ImageQuality } from './results/image_quality/ImageQuality';
+import { ImageQualityGroup } from './results/image_quality/ImageQualityGroup';
+import { ImageQualityCheckType } from './results/image_quality/ImageQualityCheckType';
+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 { LDSParsingNotificationCodes } from './results/visible_digital_seals/LDSParsingNotificationCodes';
+export { LDSParsingErrorCodes, VDSNCData, BytesData, LDSParsingNotificationCodes };
+
+import { SecurityObject } from './results/rfid/SecurityObject';
+import { CardProperties } from './results/rfid/CardProperties';
+import { DataField } from './results/rfid/DataField';
+import { Attribute } from './results/rfid/Attribute';
+import { SignerInfo } from './results/rfid/SignerInfo';
+import { SecurityObjectCertificates } from './results/rfid/SecurityObjectCertificates';
+import { CertificateChain } from './results/rfid/CertificateChain';
+import { Authority } from './results/rfid/Authority';
+import { File } from './results/rfid/File';
+import { RFIDValue } from './results/rfid/RFIDValue';
+import { RFIDValidity } from './results/rfid/RFIDValidity';
+import { RFIDDataFileType } from './results/rfid/RFIDDataFileType';
+import { CertificateData } from './results/rfid/CertificateData';
+import { FileData } from './results/rfid/FileData';
+import { RFIDCertificateType } from './results/rfid/RFIDCertificateType';
+import { RFIDSessionData } from './results/rfid/RFIDSessionData';
+import { Application, RFIDApplicationType } from './results/rfid/Application';
+import { RFIDAccessControlProcedureType } from './results/rfid/RFIDAccessControlProcedureType';
+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 { 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 } from './params/process_params/AuthenticityParams';
+import { BackendProcessingConfig } from './params/process_params/BackendProcessingConfig';
+import { FaceApiSearchParams } from './params/process_params/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 };
+
+import { CustomizationFonts } from './params/customization/CustomizationFonts';
+import { CustomizationImages } from './params/customization/CustomizationImages';
+import { Font, FontStyle } from './params/customization/Font';
+import { Customization, Cap, FrameShapeType, ViewContentMode, CustomButtonTag } from './params/customization/Customization';
+import { CustomizationColors } from './params/customization/CustomizationColors';
+export { CustomizationFonts, CustomizationImages, Font, FontStyle, Customization, Cap, FrameShapeType, ViewContentMode, CustomButtonTag, CustomizationColors };
+
+import { EPassportDataGroups } from './params/rfid_scenario/EPassportDataGroups';
+import { EIDDataGroups } from './params/rfid_scenario/EIDDataGroups';
+import { DTCDataGroup } from './params/rfid_scenario/DTCDataGroup';
+import { RFIDScenario, RFIDAuthenticationProcedureType, RFIDPasswordType, RFIDSDKProfilerType, RFIDTerminalType, SignManagementAction, RFIDReadingBufferSize } from './params/rfid_scenario/RFIDScenario';
+import { EDLDataGroups } from './params/rfid_scenario/EDLDataGroups';
+export { EPassportDataGroups, EIDDataGroups, DTCDataGroup, RFIDScenario, RFIDAuthenticationProcedureType, RFIDPasswordType, RFIDSDKProfilerType, RFIDTerminalType, SignManagementAction, RFIDReadingBufferSize, EDLDataGroups };
+
+import { PAResourcesIssuer } from './rfid/PAResourcesIssuer';
+import { RFIDErrorCodes } from './rfid/RFIDErrorCodes';
+import { TccParams } from './rfid/TccParams';
+import { RFIDNotification, RFIDNotificationCodes } from './rfid/RFIDNotification';
+import { PAAttribute } from './rfid/PAAttribute';
+import { TAChallenge } from './rfid/TAChallenge';
+import { PKDCertificate, PKDResourceType } from './rfid/PKDCertificate';
+export { PAResourcesIssuer, RFIDErrorCodes, TccParams, RFIDNotification, RFIDNotificationCodes, PAAttribute, TAChallenge, PKDCertificate, PKDResourceType };
+
+export class DocumentReader {
+    static get instance() { return DocumentReader._instance }
+    static _instance = new DocumentReader()
+
+    get availableScenarios() { return this._availableScenarios }
+    _availableScenarios = []
+
+    get version() { return this._version }
+    _version = null
+
+    get license() { return this._license }
+    _license = new License()
+
+    async isRFIDAvailableForUse() {
+        return await exec("getIsRFIDAvailableForUse", []);
+    }
+
+    async isAuthenticatorRFIDAvailableForUse() {
+        return await exec("isAuthenticatorRFIDAvailableForUse", []);
+    }
+
+    async isAuthenticatorAvailableForUse() {
+        return await exec("isAuthenticatorAvailableForUse", []);
+    }
+
+    get rfidSessionStatus() { return this._rfidSessionStatus }
+    _rfidSessionStatus = null
+    set rfidSessionStatus(val) {
+        this._rfidSessionStatus = val;
+        this._setRfidSessionStatus(val);
+    }
+
+    get tag() { return this._tag }
+    _tag = null
+    set tag(val) {
+        this._tag = val;
+        this._setTag(val);
+    }
+
+    get tenant() { return this._tenant }
+    _tenant = null
+    set tenant(val) {
+        this._tenant = val;
+        this._setTenant(val);
+    }
+
+    get env() { return this._env }
+    _env = null
+    set env(val) {
+        this._env = val;
+        this._setEnv(val);
+    }
+
+    get locale() { return this._locale }
+    _locale = null
+    set locale(val) {
+        this._locale = val;
+        this._setLocale(val);
+    }
+
+    get localizationDictionary() { return this._localizationDictionary }
+    _localizationDictionary = null
+    set localizationDictionary(val) {
+        var temp = Object.assign({}, val);
+        Object.freeze(temp);
+        this._localizationDictionary = temp
+        this._setLocalizationDictionary(val)
+    }
+
+    get functionality() { return this._functionality }
+    _functionality = new Functionality()
+    set functionality(val) {
+        this._functionality = val;
+        this._functionality._apply();
+    }
+
+    get processParams() { return this._processParams }
+    _processParams = new ProcessParams()
+    set processParams(val) {
+        this._processParams = val;
+        this._processParams._apply();
+    }
+
+    get customization() { return this._customization }
+    _customization = new Customization()
+    set customization(val) {
+        this._customization = val;
+        this._customization._apply();
+    }
+
+    get rfidScenario() { return this._rfidScenario }
+    _rfidScenario = new RFIDScenario()
+    set rfidScenario(val) {
+        this._rfidScenario = val;
+        this._rfidScenario._apply();
+    }
+
+    async isReady() {
+        return await exec("getDocumentReaderIsReady", []);
+    }
+
+    async status() {
+        return await exec("getDocumentReaderStatus", []);
+    }
+
+    resetConfiguration() {
+        exec("resetConfiguration", []);
+        this._functionality = new Functionality();
+        this._processParams = new ProcessParams();
+        this._customization = new Customization();
+        this._rfidScenario = new RFIDScenario();
+    }
+
+    set onCustomButtonTapped(completion) {
+        _setCustomButtonTappedCompletion(completion);
+    }
+
+    set videoEncoderCompletion(completion) {
+        _setVideoEncoderCompletion(completion);
+    }
+
+    async initialize(config) {
+        var response = await exec("initialize", [config])
+        var [success, error] = this._successOrErrorFromJson(response)
+        if (success) await this._onInit()
+        return [success, error]
+    }
+
+    async connectBluetoothDevice(deviceName) {
+        this.functionality.btDeviceName = deviceName;
+        return await exec("connectBluetoothDevice", [deviceName]);
+    }
+
+    deinitializeReader() {
+        exec("deinitializeReader", []);
+    }
+
+    async prepareDatabase(databaseID, prepareCompletion) {
+        _setDocumentReaderPrepareCompletion(prepareCompletion);
+        var response = await exec("prepareDatabase", [databaseID]);
+        return this._successOrErrorFromJson(response);
+    }
+
+    async runAutoUpdate(databaseID, prepareCompletion) {
+        _setDocumentReaderPrepareCompletion(prepareCompletion);
+        var response = await exec("runAutoUpdate", [databaseID]);
+        return this._successOrErrorFromJson(response);
+    }
+
+    async checkDatabaseUpdate(databaseID) {
+        var response = await exec("checkDatabaseUpdate", [databaseID]);
+        return DocumentsDatabase.fromJson(response ? JSON.parse(response) : null);
+    }
+
+    async cancelDBUpdate() {
+        return await exec("cancelDBUpdate", []);
+    }
+
+    async removeDatabase() {
+        return await exec("removeDatabase", []);
+    }
+
+    startNewPage() {
+        exec("startNewPage", []);
+    }
+
+    startNewSession() {
+        exec("startNewSession", []);
+    }
+
+    scan(config, completion) {
+        _setDocumentReaderCompletion(completion);
+        exec("scan", [config]);
+    }
+
+    startScanner(config, completion) {
+        _setDocumentReaderCompletion(completion);
+        exec("startScanner", [config]);
+    }
+
+    recognize(config, completion) {
+        _setDocumentReaderCompletion(completion);
+        exec("recognize", [config]);
+    }
+
+    rfid(config) {
+        if (config._disableUI) {
+            _setRFIDCompletion(config._rfidCompletion);
+        } else {
+            _setDocumentReaderCompletion(config._completion);
+        }
+
+        _setRFIDProgressCompletion(config.onProgress);
+        _setChipDetectedCompletion(config.onChipDetected);
+        _setRetryReadChipCompletion(config.onRetryReadChip);
+        _setPaCertificateCompletion(config.onRequestPACertificates);
+        _setTaCertificateCompletion(config.onRequestTACertificates);
+        _setTaSignatureCompletion(config.onRequestTASignature);
+
+        exec(config._disableUI ? "readRFID" : "startRFIDReader", [
+            config.onRequestPACertificates != null,
+            config.onRequestTACertificates != null,
+            config.onRequestTASignature != null,
+        ]);
+    }
+
+    stopScanner() {
+        exec("stopScanner", []);
+    }
+
+    stopRFIDReader() {
+        exec("stopRFIDReader", []);
+    }
+
+    addPKDCertificates(certificates) {
+        exec("addPKDCertificates", [certificates]);
+    }
+
+    clearPKDCertificates() {
+        exec("clearPKDCertificates", []);
+    }
+
+    async setTCCParams(params) {
+        var response = await exec("setTCCParams", [params]);
+        return this._successOrErrorFromJson(response);
+    }
+
+    async finalizePackage() {
+        var response = await exec("finalizePackage", []);
+        var jsonObject = JSON.parse(response);
+        var action = jsonObject["action"];
+        var info = TransactionInfo.fromJson(jsonObject["info"]);
+        var error = DocReaderException.fromJson(jsonObject["error"]);
+
+        return [action, info, error];
+    }
+
+    endBackendTransaction() {
+        exec("endBackendTransaction", []);
+    }
+
+    _successOrErrorFromJson(jsonString) {
+        var jsonObject = JSON.parse(jsonString);
+        var success = jsonObject["success"];
+        var error = DocReaderException.fromJson(jsonObject["error"]);
+        return [success, error];
+    }
+
+    async _onInit() {
+        this._version = await this._getDocReaderVersion();
+        this._availableScenarios = await this._getAvailableScenarios();
+        this._license = await this._getLicense();
+        this._tag = await this._getTag();
+        this._tenant = await this._getTenant();
+        this._env = await this._getEnv();
+        this._locale = await this._getLocale();
+        this._rfidSessionStatus = await this._getRfidSessionStatus();
+        this._functionality = await this._getFunctionality();
+        this._processParams = await this._getProcessParams();
+        this._customization = await this._getCustomization();
+        this._rfidScenario = await this._getRfidScenario();
+    }
+
+    async _getProcessParams() {
+        const response = await exec("getProcessParams", []);
+        return ProcessParams.fromJson(JSON.parse(response));
+    }
+
+    async _getFunctionality() {
+        const response = await exec("getFunctionality", []);
+        return Functionality.fromJson(JSON.parse(response));
+    }
+
+    async _getCustomization() {
+        const response = await exec("getCustomization", []);
+        return Customization.fromJson(JSON.parse(response));
+    }
+
+    async _getRfidScenario() {
+        const response = await exec("getRfidScenario", []);
+        return RFIDScenario.fromJson(JSON.parse(response));
+    }
+
+    async _getLicense() {
+        const response = await exec("getLicense", []);
+        return License.fromJson(response ? JSON.parse(response) : {});
+    }
+
+    async _getAvailableScenarios() {
+        const response = await exec("getAvailableScenarios", []);
+        const scenarios = [];
+        for (const s of JSON.parse(response)) {
+            scenarios.push(DocReaderScenario.fromJson(s));
+        }
+        return scenarios;
+    }
+
+    async _getDocReaderVersion() {
+        const response = await exec("getDocReaderVersion", []);
+        return DocReaderVersion.fromJson(response ? JSON.parse(response) : null);
+    }
+
+    async _getRfidSessionStatus() {
+        return await exec("getRfidSessionStatus", []);
+    }
+
+    _setRfidSessionStatus(status) {
+        exec("setRfidSessionStatus", [status]);
+    }
+
+    async _getTag() {
+        return await exec("getTag", []);
+    }
+
+    _setTag(tag) {
+        exec("setTag", [tag]);
+    }
+
+    async _getTenant() {
+        return await exec("getTenant", []);
+    }
+
+    _setTenant(tenant) {
+        exec("setTenant", [tenant]);
+    }
+
+    async _getEnv() {
+        return await exec("getEnv", []);
+    }
+
+    _setEnv(env) {
+        exec("setEnv", [env]);
+    }
+
+    async _getLocale() {
+        return await exec("getLocale", []);
+    }
+
+    _setLocale(locale) {
+        exec("setLocale", [locale]);
+    }
+
+    _setLocalizationDictionary(dictionary) {
+        exec("setLocalizationDictionary", [dictionary]);
+    }
+}
+
+export const DocReaderAction = {
+    COMPLETE: 0,
+    PROCESS: 1,
+    MORE_PAGES_AVAILABLE: 2,
+    CANCEL: 3,
+    ERROR: 4,
+    PROCESS_WHITE_FLASHLIGHT: 5,
+    TIMEOUT: 6,
+    PROCESSING_ON_SERVICE: 7,
+    PROCESS_WHITE_UV_IMAGES: 102,
+    PROCESS_IR_FRAME: 103
+};
+
+DocReaderAction.finished = function (value) {
+    return value == DocReaderAction.COMPLETE || value == DocReaderAction.TIMEOUT
+}
+DocReaderAction.interrupted = function (value) {
+    return value == DocReaderAction.CANCEL || value == DocReaderAction.ERROR
+}
+DocReaderAction.stopped = function (value) {
+    return DocReaderAction.finished(value) || DocReaderAction.interrupted(value)
+}

package/www/capacitor/info/DocReaderException.js

@@ -0,0 +1,64 @@
+export class DocReaderException {
+    code
+    message
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DocReaderException()
+
+        result.code = jsonObject["code"]
+        result.message = jsonObject["message"] ?? ""
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "code": this.code,
+            "message": this.message,
+        }
+    }
+}
+
+export const ErrorCodes = {
+    INITIALIZATION_CORE_ABSENT: 0,
+    INITIALIZATION_FAILED: 1,
+    INCORRECT_SCENARIO: 2,
+    NO_RESULT: 3,
+    REMOVE_DATABASE: 4,
+    FETCHING_DATABASE: 5,
+    DB_ID_NOT_FOUND: 6,
+    DB_DESCRIPTION_NOT_FOUND: 7,
+    SAVE_DB: 8,
+    DOWNLOAD_DB_INCORRECT_CHECKSUM: 9,
+    DB_DOWNLOAD: 10,
+    DB_CREATION: 11,
+    RFID_ERROR: 12,
+    LICENSE_ABSENT_OR_CORRUPTED: 13,
+    LICENSE_INVALID_DATE: 14,
+    LICENSE_INVALID_VERSION: 15,
+    LICENSE_INVALID_DEVICE_ID: 16,
+    LICENSE_INVALID_SYSTEM_OR_APP_ID: 17,
+    LICENSE_NO_CAPABILITIES: 18,
+    LICENSE_NO_AUTHENTICITY: 19,
+    RECORD_PROCESS_INVALID_OUTPUT_URL: 20,
+    LICENSE_ONLINE_ERROR: 21,
+    LICENSE_NO_DATABASE: 22,
+    LICENSE_DATABASE_INCORRECT: 23,
+    INVALID_TCC_PARAMS: 24,
+    RFID_IN_PROGRESS: 25,
+    START_BACKEND_PROCESSING: 26,
+    ADD_DATA_TO_PACKAGE: 27,
+    FINALIZE_FAILED: 28,
+    CAMERA_NO_PERMISSION: 29,
+    CAMERA_NOT_AVAILABLE: 30,
+    CANNOT_USE_CAMERA_IN_SCENARIO: 40,
+    BACKEND_ONLINE_PROCESSING: 303,
+    WRONG_INPUT: 400,
+    STATE_EXCEPTION: 500,
+    BLE_EXCEPTION: 600,
+    FEATURE_BLUETOOTH_LE_NOT_SUPPORTED: 601,
+    APP_BACKGROUND: 700,
+    ONLINE_PROCESSING_WRONG_INPUT: 800,
+    NATIVE_JAVA_EXCEPTION: 1000
+}

package/www/capacitor/info/DocReaderScenario.js

@@ -0,0 +1,89 @@
+export class DocReaderScenario {
+    name
+    caption
+    description
+    frameOrientation
+    uvTorch
+    faceExt
+    multiPageOff
+    seriesProcessMode
+    frameKWHLandscape
+    frameKWHPortrait
+    frameKWHDoublePageSpreadLandscape
+    frameKWHDoublePageSpreadPortrait
+    manualCrop
+
+    constructor() {
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DocReaderScenario()
+
+        result.uvTorch = jsonObject["uvTorch"]
+        result.frameOrientation = jsonObject["frameOrientation"]
+        result.faceExt = jsonObject["faceExt"]
+        result.multiPageOff = jsonObject["multiPageOff"]
+        result.seriesProcessMode = jsonObject["seriesProcessMode"]
+        result.frameKWHLandscape = jsonObject["frameKWHLandscape"]
+        result.frameKWHPortrait = jsonObject["frameKWHPortrait"]
+        result.frameKWHDoublePageSpreadPortrait = jsonObject["frameKWHDoublePageSpreadPortrait"]
+        result.frameKWHDoublePageSpreadLandscape = jsonObject["frameKWHDoublePageSpreadLandscape"]
+        result.name = jsonObject["name"]
+        result.caption = jsonObject["caption"]
+        result.description = jsonObject["description"]
+        result.manualCrop = jsonObject["manualCrop"]
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "uvTorch": this.uvTorch,
+            "frameOrientation": this.frameOrientation,
+            "faceExt": this.faceExt,
+            "multiPageOff": this.multiPageOff,
+            "seriesProcessMode": this.seriesProcessMode,
+            "frameKWHLandscape": this.frameKWHLandscape,
+            "frameKWHPortrait": this.frameKWHPortrait,
+            "frameKWHDoublePageSpreadPortrait": this.frameKWHDoublePageSpreadPortrait,
+            "frameKWHDoublePageSpreadLandscape": this.frameKWHDoublePageSpreadLandscape,
+            "name": this.name,
+            "caption": this.caption,
+            "description": this.description,
+            "manualCrop": this.manualCrop,
+        }
+    }
+}
+
+export const Scenario = {
+    MRZ: "Mrz",
+    BARCODE: "Barcode",
+    LOCATE: "Locate",
+    OCR: "Ocr",
+    DOCTYPE: "DocType",
+    MRZ_OR_BARCODE: "MrzOrBarcode",
+    MRZ_OR_LOCATE: "MrzOrLocate",
+    MRZ_AND_LOCATE: "MrzAndLocate",
+    BARCODE_AND_LOCATE: "BarcodeAndLocate",
+    MRZ_OR_OCR: "MrzOrOcr",
+    MRZ_OR_BARCODE_OR_OCR: "MrzOrBarcodeOrOcr",
+    LOCATE_VISUAL_AND_MRZ_OR_OCR: "LocateVisual_And_MrzOrOcr",
+    FULL_PROCESS: "FullProcess",
+    FULL_AUTH: "FullAuth",
+    ID3RUS: "Id3Rus",
+    RUS_STAMP: "RusStamp",
+    OCR_FREE: "OcrFree",
+    CREDIT_CARD: "CreditCard",
+    CAPTURE: "Capture",
+    DTC: "DTC",
+    RFID: "RFID"
+}
+
+export const DocReaderOrientation = {
+    ALL: 0,
+    PORTRAIT: 1,
+    LANDSCAPE: 2,
+    LANDSCAPE_LEFT: 3,
+    LANDSCAPE_RIGHT: 4
+}

package/www/capacitor/info/DocReaderVersion.js

@@ -0,0 +1,32 @@
+import { DocumentsDatabase } from "./DocumentsDatabase";
+
+export class DocReaderVersion {
+    api
+    core
+    coreMode
+    database
+
+    constructor() {
+    }
+
+    static fromJson(jsonObject) {
+        if (jsonObject == null) return null
+        const result = new DocReaderVersion()
+
+        result.api = jsonObject["api"]
+        result.core = jsonObject["core"]
+        result.coreMode = jsonObject["coreMode"]
+        result.database = DocumentsDatabase.fromJson(jsonObject["database"])
+
+        return result
+    }
+
+    toJson() {
+        return {
+            "api": this.api,
+            "core": this.core,
+            "coreMode": this.coreMode,
+            "database": this.database?.toJson(),
+        }
+    }
+}