@regulaforensics/react-native-document-reader-api 7.1.0 → 7.2.0

package/index.d.ts

@@ -972,7 +972,7 @@ export class DocumentReaderBarcodeField {
     status?: number
     pageIndex?: number
     pdf417Info?: PDF417Info
-    data?: any[]
+    data?: string
 
     static fromJson(jsonObject?: any): DocumentReaderBarcodeField | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
@@ -982,12 +982,7 @@ export class DocumentReaderBarcodeField {
         result.status = jsonObject["status"]
         result.pageIndex = jsonObject["pageIndex"]
         result.pdf417Info = PDF417Info.fromJson(jsonObject["pdf417Info"])
-        result.data = []
-        if (jsonObject["data"] != null) {
-            for (const i in jsonObject["data"]) {
-                result.data.push(jsonObject["data"][i])
-            }
-        }
+        result.data = jsonObject["data"]
 
         return result
     }
@@ -1143,7 +1138,7 @@ export class ImageInputParam {
 }
 
 export class PAResourcesIssuer {
-    data?: any[]
+    data?: string
     friendlyName?: string
     attributes?: PAAttribute[]
 
@@ -1151,12 +1146,7 @@ export class PAResourcesIssuer {
         if (jsonObject == null || jsonObject == undefined) return undefined
         const result = new PAResourcesIssuer
 
-        result.data = []
-        if (jsonObject["data"] != null) {
-            for (const i in jsonObject["data"]) {
-                result.data.push(jsonObject["data"][i])
-            }
-        }
+        result.data = jsonObject["data"]
         result.friendlyName = jsonObject["friendlyName"]
         result.attributes = []
         if (jsonObject["attributes"] != null) {
@@ -1187,7 +1177,7 @@ export class PAAttribute {
 }
 
 export class TAChallenge {
-    data?: any[]
+    data?: string
     auxPCD?: string
     challengePICC?: string
     hashPK?: string
@@ -1197,12 +1187,7 @@ export class TAChallenge {
         if (jsonObject == null || jsonObject == undefined) return undefined
         const result = new TAChallenge
 
-        result.data = []
-        if (jsonObject["data"] != null) {
-            for (const i in jsonObject["data"]) {
-                result.data.push(jsonObject["data"][i])
-            }
-        }
+        result.data = jsonObject["data"]
         result.auxPCD = jsonObject["auxPCD"]
         result.challengePICC = jsonObject["challengePICC"]
         result.hashPK = jsonObject["hashPK"]
@@ -1295,7 +1280,7 @@ export class VDSNCData {
     type?: string
     version?: number
     issuingCountry?: string
-    message?: any
+    message?: Record<string, any>
     signatureAlgorithm?: string
     signature?: BytesData
     certificate?: BytesData
@@ -1358,7 +1343,7 @@ export class ImageInputData {
     width?: number
     height?: number
     bitmap?: string
-    imgBytes?: any[]
+    imgBytes?: string
 
     static fromJson(jsonObject?: any): ImageInputData | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
@@ -1370,12 +1355,7 @@ export class ImageInputData {
         result.width = jsonObject["width"]
         result.height = jsonObject["height"]
         result.bitmap = jsonObject["bitmap"]
-        result.imgBytes = []
-        if (jsonObject["imgBytes"] != null) {
-            for (const i in jsonObject["imgBytes"]) {
-                result.imgBytes.push(jsonObject["imgBytes"][i])
-            }
-        }
+        result.imgBytes = jsonObject["imgBytes"]
 
         return result
     }
@@ -1491,188 +1471,10 @@ export class DocumentReaderValidity {
     }
 }
 
-export class FaceApiParams {
-    url?: string
-    mode?: string
-    searchParams?: Search
-    threshold?: number
-    serviceTimeout?: number
-    proxy?: string
-    proxyPassword?: string
-    proxyType?: number
-
-    static fromJson(jsonObject?: any): FaceApiParams | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new FaceApiParams
-
-        result.url = jsonObject["url"]
-        result.mode = jsonObject["mode"]
-        result.searchParams = Search.fromJson(jsonObject["searchParams"])
-        result.threshold = jsonObject["threshold"]
-        result.serviceTimeout = jsonObject["serviceTimeout"]
-        result.proxy = jsonObject["proxy"]
-        result.proxyPassword = jsonObject["proxyPassword"]
-        result.proxyType = jsonObject["proxyType"]
-
-        return result
-    }
-}
-
-export class Search {
-    limit?: number
-    threshold?: number
-    groupIds?: number[]
-
-    static fromJson(jsonObject?: any): Search | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new Search
-
-        result.limit = jsonObject["limit"]
-        result.threshold = jsonObject["threshold"]
-        result.groupIds = []
-        if (jsonObject["groupIds"] != null) {
-            for (const i in jsonObject["groupIds"]) {
-                result.groupIds.push(jsonObject["groupIds"][i])
-            }
-        }
-
-        return result
-    }
-}
-
-export class AuthenticityParams {
-    useLivenessCheck?: boolean
-    livenessParams?: LivenessParams
-    checkUVLuminiscence?: boolean
-    checkIRB900?: boolean
-    checkImagePatterns?: boolean
-    checkFibers?: boolean
-    checkExtMRZ?: boolean
-    checkExtOCR?: boolean
-    checkAxial?: boolean
-    checkBarcodeFormat?: boolean
-    checkIRVisibility?: boolean
-    checkIPI?: boolean
-    checkPhotoEmbedding?: boolean
-    checkPhotoComparison?: boolean
-    checkLetterScreen?: boolean
-
-    static fromJson(jsonObject?: any): AuthenticityParams | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        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"]
-
-        return result
-    }
-}
-
-export class LivenessParams {
-    checkOVI?: boolean
-    checkMLI?: boolean
-    checkHolo?: boolean
-    checkED?: boolean
-
-    static fromJson(jsonObject?: any): LivenessParams | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new LivenessParams
-
-        result.checkOVI = jsonObject["checkOVI"]
-        result.checkMLI = jsonObject["checkMLI"]
-        result.checkHolo = jsonObject["checkHolo"]
-        result.checkED = jsonObject["checkED"]
-
-        return result
-    }
-}
-
-export class ImageQA {
-    dpiThreshold?: number
-    angleThreshold?: number
-    focusCheck?: boolean
-    glaresCheck?: boolean
-    colornessCheck?: boolean
-    screenCapture?: boolean
-    documentPositionIndent?: number
-    expectedPass?: number[]
-    glaresCheckParams?: GlaresCheckParams
-    brightnessThreshold?: number
-
-    static fromJson(jsonObject?: any): ImageQA | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        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.documentPositionIndent = jsonObject["documentPositionIndent"]
-        result.expectedPass = []
-        if (jsonObject["expectedPass"] != null) {
-            for (const i in jsonObject["expectedPass"]) {
-                result.expectedPass.push(jsonObject["expectedPass"][i])
-            }
-        }
-        result.glaresCheckParams = GlaresCheckParams.fromJson(jsonObject["glaresCheckParams"])
-        result.brightnessThreshold = jsonObject["brightnessThreshold"]
-
-        return result
-    }
-}
-
-export class GlaresCheckParams {
-    imgMarginPart?: number
-    maxGlaringPart?: number
-
-    static fromJson(jsonObject?: any): GlaresCheckParams | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new GlaresCheckParams
-
-        result.imgMarginPart = jsonObject["imgMarginPart"]
-        result.maxGlaringPart = jsonObject["maxGlaringPart"]
-
-        return result
-    }
-}
-
-export class RFIDParams {
-    paIgnoreNotificationCodes?: number[]
-
-    static fromJson(jsonObject?: any): RFIDParams | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new RFIDParams
-
-        result.paIgnoreNotificationCodes = []
-        if (jsonObject["paIgnoreNotificationCodes"] != null) {
-            for (const i in jsonObject["paIgnoreNotificationCodes"]) {
-                result.paIgnoreNotificationCodes.push(jsonObject["paIgnoreNotificationCodes"][i])
-            }
-        }
-
-        return result
-    }
-}
-
 export class OnlineProcessingConfig {
     mode?: number
     url?: string
-    processParam?: any
+    processParam?: ProcessParams
     imageFormat?: number
     imageCompressionQuality?: number
 
@@ -1682,7 +1484,7 @@ export class OnlineProcessingConfig {
 
         result.mode = jsonObject["mode"]
         result.url = jsonObject["url"]
-        result.processParam = jsonObject["processParam"]
+        result.processParam = ProcessParams.fromJson(jsonObject["processParam"])
         result.imageFormat = jsonObject["imageFormat"]
         result.imageCompressionQuality = jsonObject["imageCompressionQuality"]
 
@@ -1696,7 +1498,7 @@ export class DocReaderConfig {
     databasePath?: string
     licenseUpdate?: boolean
     delayedNNLoad?: boolean
-    blackList?: any
+    blackList?: Record<string, string>
 
     static fromJson(jsonObject?: any): DocReaderConfig | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
@@ -1745,239 +1547,1205 @@ export class RecognizeConfig {
     images?: string[]
     imageInputData?: ImageInputData[]
 
-    static fromJson(jsonObject?: any): RecognizeConfig | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new RecognizeConfig
+    static fromJson(jsonObject?: any): RecognizeConfig | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new RecognizeConfig
+
+        result.scenario = jsonObject["scenario"]
+        result.onlineProcessingConfig = OnlineProcessingConfig.fromJson(jsonObject["onlineProcessingConfig"])
+        result.oneShotIdentification = jsonObject["oneShotIdentification"]
+        result.livePortrait = jsonObject["livePortrait"]
+        result.extPortrait = jsonObject["extPortrait"]
+        result.image = jsonObject["image"]
+        result.data = jsonObject["data"]
+        result.images = []
+        if (jsonObject["images"] != null) {
+            for (const i in jsonObject["images"]) {
+                result.images.push(jsonObject["images"][i])
+            }
+        }
+        result.imageInputData = []
+        if (jsonObject["imageInputData"] != null) {
+            for (const i in jsonObject["imageInputData"]) {
+                const item = ImageInputData.fromJson(jsonObject["imageInputData"][i])
+                if (item != undefined)
+                    result.imageInputData.push(item)
+            }
+        }
+
+        return result
+    }
+}
+
+export class License {
+    expiryDate?: string
+    countryFilter?: string[]
+    isRfidAvailable?: boolean
+
+    static fromJson(jsonObject?: any): License | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new License
+
+        result.expiryDate = jsonObject["expiryDate"]
+        result.countryFilter = []
+        if (jsonObject["countryFilter"] != null) {
+            for (const i in jsonObject["countryFilter"]) {
+                result.countryFilter.push(jsonObject["countryFilter"][i])
+            }
+        }
+        result.isRfidAvailable = jsonObject["isRfidAvailable"]
+
+        return result
+    }
+}
+
+export class DocReaderVersion {
+    api?: string
+    core?: string
+    coreMode?: string
+    database?: DocReaderDocumentsDatabase
+
+    static fromJson(jsonObject?: any): DocReaderVersion | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new DocReaderVersion
+
+        result.api = jsonObject["api"]
+        result.core = jsonObject["core"]
+        result.coreMode = jsonObject["coreMode"]
+        result.database = DocReaderDocumentsDatabase.fromJson(jsonObject["database"])
+
+        return result
+    }
+}
+
+export class TransactionInfo {
+    transactionId?: string
+    tag?: string
+
+    static fromJson(jsonObject?: any): TransactionInfo | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new TransactionInfo
+
+        result.transactionId = jsonObject["transactionId"]
+        result.tag = jsonObject["tag"]
+
+        return result
+    }
+}
+
+export class DocumentReaderResults {
+    chipPage?: number
+    processingFinishedStatus?: number
+    elapsedTime?: number
+    elapsedTimeRFID?: number
+    morePagesAvailable?: number
+    graphicResult?: DocumentReaderGraphicResult
+    textResult?: DocumentReaderTextResult
+    documentPosition?: ElementPosition[]
+    barcodePosition?: ElementPosition[]
+    mrzPosition?: ElementPosition[]
+    imageQuality?: ImageQualityGroup[]
+    rawResult?: string
+    rfidSessionData?: RFIDSessionData
+    authenticityResult?: DocumentReaderAuthenticityResult
+    barcodeResult?: DocumentReaderBarcodeResult
+    documentType?: DocumentReaderDocumentType[]
+    status?: DocumentReaderResultsStatus
+    vdsncData?: VDSNCData
+    transactionInfo?: TransactionInfo
+
+    textFieldValueByType(fieldType, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByType", [this.rawResult, fieldType], successCallback, errorCallback)
+    }
+
+    textFieldValueByTypeLcid(fieldType, lcid, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcid", [this.rawResult, fieldType, lcid], successCallback, errorCallback)
+    }
+
+    textFieldValueByTypeSource(fieldType, source, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
+    }
+
+    textFieldValueByTypeLcidSource(fieldType, lcid, source, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcidSource", [this.rawResult, fieldType, lcid, source], successCallback, errorCallback)
+    }
+
+    textFieldValueByTypeSourceOriginal(fieldType, source, original, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeSourceOriginal", [this.rawResult, fieldType, source, original], successCallback, errorCallback)
+    }
+
+    textFieldValueByTypeLcidSourceOriginal(fieldType, lcid, source, original, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcidSourceOriginal", [this.rawResult, fieldType, lcid, source, original], successCallback, errorCallback)
+    }
+
+    textFieldByType(fieldType, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldByType", [this.rawResult, fieldType], successCallback, errorCallback)
+    }
+
+    textFieldByTypeLcid(fieldType, lcid, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "textFieldByTypeLcid", [this.rawResult, fieldType, lcid], successCallback, errorCallback)
+    }
+
+    graphicFieldByTypeSource(fieldType, source, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
+    }
+
+    graphicFieldByTypeSourcePageIndex(fieldType, source, pageIndex, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex], successCallback, errorCallback)
+    }
+
+    graphicFieldByTypeSourcePageIndexLight(fieldType, source, pageIndex, light, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex, light], successCallback, errorCallback)
+    }
+
+    graphicFieldImageByType(fieldType, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByType", [this.rawResult, fieldType], successCallback, errorCallback)
+    }
+
+    graphicFieldImageByTypeSource(fieldType, source, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
+    }
+
+    graphicFieldImageByTypeSourcePageIndex(fieldType, source, pageIndex, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex], successCallback, errorCallback)
+    }
+
+    graphicFieldImageByTypeSourcePageIndexLight(fieldType, source, pageIndex, light, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSourcePageIndexLight", [this.rawResult, fieldType, source, pageIndex, light], successCallback, errorCallback)
+    }
+
+    containers(resultType, successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "containers", [this.rawResult, resultType], successCallback, errorCallback)
+    }
+
+    encryptedContainers(successCallback, errorCallback) {
+        RNRegulaDocumentReader.exec("DocumentReader", "encryptedContainers", [this.rawResult], successCallback, errorCallback)
+    }
+
+    static fromJson(jsonObject?: any): DocumentReaderResults | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new DocumentReaderResults
+
+        result.chipPage = jsonObject["chipPage"]
+        result.processingFinishedStatus = jsonObject["processingFinishedStatus"]
+        result.elapsedTime = jsonObject["elapsedTime"]
+        result.elapsedTimeRFID = jsonObject["elapsedTimeRFID"]
+        result.morePagesAvailable = jsonObject["morePagesAvailable"]
+        result.graphicResult = DocumentReaderGraphicResult.fromJson(jsonObject["graphicResult"])
+        result.textResult = DocumentReaderTextResult.fromJson(jsonObject["textResult"])
+        result.documentPosition = []
+        if (jsonObject["documentPosition"] != null) {
+            for (const i in jsonObject["documentPosition"]) {
+                const item = ElementPosition.fromJson(jsonObject["documentPosition"][i])
+                if (item != undefined)
+                    result.documentPosition.push(item)
+            }
+        }
+        result.barcodePosition = []
+        if (jsonObject["barcodePosition"] != null) {
+            for (const i in jsonObject["barcodePosition"]) {
+                const item = ElementPosition.fromJson(jsonObject["barcodePosition"][i])
+                if (item != undefined)
+                    result.barcodePosition.push(item)
+            }
+        }
+        result.mrzPosition = []
+        if (jsonObject["mrzPosition"] != null) {
+            for (const i in jsonObject["mrzPosition"]) {
+                const item = ElementPosition.fromJson(jsonObject["mrzPosition"][i])
+                if (item != undefined)
+                    result.mrzPosition.push(item)
+            }
+        }
+        result.imageQuality = []
+        if (jsonObject["imageQuality"] != null) {
+            for (const i in jsonObject["imageQuality"]) {
+                const item = ImageQualityGroup.fromJson(jsonObject["imageQuality"][i])
+                if (item != undefined)
+                    result.imageQuality.push(item)
+            }
+        }
+        result.rawResult = jsonObject["rawResult"]
+        result.rfidSessionData = RFIDSessionData.fromJson(jsonObject["rfidSessionData"])
+        result.authenticityResult = DocumentReaderAuthenticityResult.fromJson(jsonObject["authenticityResult"])
+        result.barcodeResult = DocumentReaderBarcodeResult.fromJson(jsonObject["barcodeResult"])
+        result.documentType = []
+        if (jsonObject["documentType"] != null) {
+            for (const i in jsonObject["documentType"]) {
+                const item = DocumentReaderDocumentType.fromJson(jsonObject["documentType"][i])
+                if (item != undefined)
+                    result.documentType.push(item)
+            }
+        }
+        result.status = DocumentReaderResultsStatus.fromJson(jsonObject["status"])
+        result.vdsncData = VDSNCData.fromJson(jsonObject["vdsncData"])
+        result.transactionInfo = TransactionInfo.fromJson(jsonObject["transactionInfo"])
+
+        return result
+    }
+}
+
+export class CameraSize {
+    width?: number
+    height?: number
+
+    static fromJson(jsonObject?: any): CameraSize | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new CameraSize
+
+        result.width = jsonObject["width"]
+        result.height = jsonObject["height"]
+
+        return result
+    }
+}
+
+export class Functionality {
+    pictureOnBoundsReady?: boolean
+    showTorchButton?: boolean
+    showCloseButton?: boolean
+    videoCaptureMotionControl?: boolean
+    showCaptureButton?: boolean
+    showChangeFrameButton?: boolean
+    showSkipNextPageButton?: boolean
+    useAuthenticator?: boolean
+    skipFocusingFrames?: boolean
+    showCameraSwitchButton?: boolean
+    displayMetadata?: boolean
+    isZoomEnabled?: boolean
+    isCameraTorchCheckDisabled?: boolean
+    recordScanningProcess?: boolean
+    manualMultipageMode?: boolean
+    singleResult?: boolean
+    showCaptureButtonDelayFromDetect?: number
+    showCaptureButtonDelayFromStart?: number
+    rfidTimeout?: number
+    forcePagesCount?: number
+    orientation?: number
+    captureMode?: number
+    cameraMode?: number
+    cameraPositionIOS?: number
+    cameraFrame?: string
+    btDeviceName?: string
+    zoomFactor?: number
+    exposure?: number
+    excludedCamera2Models?: string[]
+    cameraSize?: CameraSize
+    videoSessionPreset?: number
+
+    static fromJson(jsonObject?: any): Functionality | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new Functionality
+
+        result.pictureOnBoundsReady = jsonObject["pictureOnBoundsReady"]
+        result.showTorchButton = jsonObject["showTorchButton"]
+        result.showCloseButton = jsonObject["showCloseButton"]
+        result.videoCaptureMotionControl = jsonObject["videoCaptureMotionControl"]
+        result.showCaptureButton = jsonObject["showCaptureButton"]
+        result.showChangeFrameButton = jsonObject["showChangeFrameButton"]
+        result.showSkipNextPageButton = jsonObject["showSkipNextPageButton"]
+        result.useAuthenticator = jsonObject["useAuthenticator"]
+        result.skipFocusingFrames = jsonObject["skipFocusingFrames"]
+        result.showCameraSwitchButton = jsonObject["showCameraSwitchButton"]
+        result.displayMetadata = jsonObject["displayMetadata"]
+        result.isZoomEnabled = jsonObject["isZoomEnabled"]
+        result.isCameraTorchCheckDisabled = jsonObject["isCameraTorchCheckDisabled"]
+        result.recordScanningProcess = jsonObject["recordScanningProcess"]
+        result.manualMultipageMode = jsonObject["manualMultipageMode"]
+        result.singleResult = jsonObject["singleResult"]
+        result.showCaptureButtonDelayFromDetect = jsonObject["showCaptureButtonDelayFromDetect"]
+        result.showCaptureButtonDelayFromStart = jsonObject["showCaptureButtonDelayFromStart"]
+        result.rfidTimeout = jsonObject["rfidTimeout"]
+        result.forcePagesCount = jsonObject["forcePagesCount"]
+        result.orientation = jsonObject["orientation"]
+        result.captureMode = jsonObject["captureMode"]
+        result.cameraMode = jsonObject["cameraMode"]
+        result.cameraPositionIOS = jsonObject["cameraPositionIOS"]
+        result.cameraFrame = jsonObject["cameraFrame"]
+        result.btDeviceName = jsonObject["btDeviceName"]
+        result.zoomFactor = jsonObject["zoomFactor"]
+        result.exposure = jsonObject["exposure"]
+        result.excludedCamera2Models = []
+        if (jsonObject["excludedCamera2Models"] != null) {
+            for (const i in jsonObject["excludedCamera2Models"]) {
+                result.excludedCamera2Models.push(jsonObject["excludedCamera2Models"][i])
+            }
+        }
+        result.cameraSize = CameraSize.fromJson(jsonObject["cameraSize"])
+        result.videoSessionPreset = jsonObject["videoSessionPreset"]
+
+        return result
+    }
+}
+
+export class GlaresCheckParams {
+    imgMarginPart?: number
+    maxGlaringPart?: number
+
+    static fromJson(jsonObject?: any): GlaresCheckParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new GlaresCheckParams
+
+        result.imgMarginPart = jsonObject["imgMarginPart"]
+        result.maxGlaringPart = jsonObject["maxGlaringPart"]
+
+        return result
+    }
+}
+
+export class ImageQA {
+    dpiThreshold?: number
+    angleThreshold?: number
+    focusCheck?: boolean
+    glaresCheck?: boolean
+    glaresCheckParams?: GlaresCheckParams
+    colornessCheck?: boolean
+    screenCapture?: boolean
+    expectedPass?: number[]
+    documentPositionIndent?: number
+    brightnessThreshold?: number
+
+    static fromJson(jsonObject?: any): ImageQA | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new ImageQA
+
+        result.dpiThreshold = jsonObject["dpiThreshold"]
+        result.angleThreshold = jsonObject["angleThreshold"]
+        result.focusCheck = jsonObject["focusCheck"]
+        result.glaresCheck = jsonObject["glaresCheck"]
+        result.glaresCheckParams = GlaresCheckParams.fromJson(jsonObject["glaresCheckParams"])
+        result.colornessCheck = jsonObject["colornessCheck"]
+        result.screenCapture = jsonObject["screenCapture"]
+        result.expectedPass = []
+        if (jsonObject["expectedPass"] != null) {
+            for (const i in jsonObject["expectedPass"]) {
+                result.expectedPass.push(jsonObject["expectedPass"][i])
+            }
+        }
+        result.documentPositionIndent = jsonObject["documentPositionIndent"]
+        result.brightnessThreshold = jsonObject["brightnessThreshold"]
+
+        return result
+    }
+}
+
+export class RFIDParams {
+    paIgnoreNotificationCodes?: number[]
+
+    static fromJson(jsonObject?: any): RFIDParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new RFIDParams
+
+        result.paIgnoreNotificationCodes = []
+        if (jsonObject["paIgnoreNotificationCodes"] != null) {
+            for (const i in jsonObject["paIgnoreNotificationCodes"]) {
+                result.paIgnoreNotificationCodes.push(jsonObject["paIgnoreNotificationCodes"][i])
+            }
+        }
+
+        return result
+    }
+}
+
+export class FaceApiSearchParams {
+    limit?: number
+    threshold?: number
+    groupIds?: number[]
+
+    static fromJson(jsonObject?: any): FaceApiSearchParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new FaceApiSearchParams
+
+        result.limit = jsonObject["limit"]
+        result.threshold = jsonObject["threshold"]
+        result.groupIds = []
+        if (jsonObject["groupIds"] != null) {
+            for (const i in jsonObject["groupIds"]) {
+                result.groupIds.push(jsonObject["groupIds"][i])
+            }
+        }
+
+        return result
+    }
+}
+
+export class FaceApiParams {
+    url?: string
+    mode?: string
+    threshold?: number
+    searchParams?: FaceApiSearchParams
+    serviceTimeout?: number
+    proxy?: string
+    proxyPassword?: string
+    proxyType?: number
+
+    static fromJson(jsonObject?: any): FaceApiParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new FaceApiParams
+
+        result.url = jsonObject["url"]
+        result.mode = jsonObject["mode"]
+        result.threshold = jsonObject["threshold"]
+        result.searchParams = FaceApiSearchParams.fromJson(jsonObject["searchParams"])
+        result.serviceTimeout = jsonObject["serviceTimeout"]
+        result.proxy = jsonObject["proxy"]
+        result.proxyPassword = jsonObject["proxyPassword"]
+        result.proxyType = jsonObject["proxyType"]
+
+        return result
+    }
+}
+
+export class BackendProcessingConfig {
+    url?: string
+    httpHeaders?: Record<string, string>
+    rfidServerSideChipVerification?: boolean
+
+    static fromJson(jsonObject?: any): BackendProcessingConfig | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new BackendProcessingConfig
+
+        result.url = jsonObject["url"]
+        result.httpHeaders = jsonObject["httpHeaders"]
+        result.rfidServerSideChipVerification = jsonObject["rfidServerSideChipVerification"]
+
+        return result
+    }
+}
+
+export class LivenessParams {
+    checkOVI?: boolean
+    checkMLI?: boolean
+    checkHolo?: boolean
+    checkED?: boolean
+
+    static fromJson(jsonObject?: any): LivenessParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new LivenessParams
+
+        result.checkOVI = jsonObject["checkOVI"]
+        result.checkMLI = jsonObject["checkMLI"]
+        result.checkHolo = jsonObject["checkHolo"]
+        result.checkED = jsonObject["checkED"]
+
+        return result
+    }
+}
+
+export class AuthenticityParams {
+    useLivenessCheck?: boolean
+    livenessParams?: LivenessParams
+    checkUVLuminiscence?: boolean
+    checkIRB900?: boolean
+    checkImagePatterns?: boolean
+    checkFibers?: boolean
+    checkExtMRZ?: boolean
+    checkExtOCR?: boolean
+    checkAxial?: boolean
+    checkBarcodeFormat?: boolean
+    checkIRVisibility?: boolean
+    checkIPI?: boolean
+    checkPhotoEmbedding?: boolean
+    checkPhotoComparison?: boolean
+    checkLetterScreen?: boolean
+
+    static fromJson(jsonObject?: any): AuthenticityParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        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"]
+
+        return result
+    }
+}
 
+export class ProcessParams {
+    multipageProcessing?: boolean
+    logs?: boolean
+    debugSaveImages?: boolean
+    debugSaveLogs?: boolean
+    returnUncroppedImage?: boolean
+    uvTorchEnabled?: boolean
+    debugSaveCroppedImages?: boolean
+    disableFocusingCheck?: boolean
+    debugSaveRFIDSession?: boolean
+    doublePageSpread?: boolean
+    manualCrop?: boolean
+    integralImage?: boolean
+    returnCroppedBarcode?: boolean
+    checkRequiredTextFields?: boolean
+    depersonalizeLog?: boolean
+    generateDoublePageSpreadImage?: boolean
+    alreadyCropped?: boolean
+    matchTextFieldMask?: boolean
+    updateOCRValidityByGlare?: boolean
+    noGraphics?: boolean
+    multiDocOnImage?: boolean
+    forceReadMrzBeforeLocate?: boolean
+    parseBarcodes?: boolean
+    shouldReturnPackageForReprocess?: boolean
+    disablePerforationOCR?: boolean
+    respectImageQuality?: boolean
+    splitNames?: boolean
+    useFaceApi?: boolean
+    useAuthenticityCheck?: boolean
+    checkHologram?: boolean
+    barcodeParserType?: number
+    perspectiveAngle?: number
+    minDPI?: number
+    imageDpiOutMax?: number
+    forceDocFormat?: number
+    shiftExpiryDate?: number
+    minimalHolderAge?: number
+    imageOutputMaxHeight?: number
+    imageOutputMaxWidth?: number
+    processAuth?: number
+    convertCase?: number
+    measureSystem?: number
+    forceDocID?: number
+    dateFormat?: string
+    scenario?: string
+    captureButtonScenario?: string
+    sessionLogFolder?: string
+    timeout?: number
+    timeoutFromFirstDetect?: number
+    timeoutFromFirstDocType?: number
+    documentAreaMin?: number
+    documentIDList?: number[]
+    barcodeTypes?: number[]
+    fieldTypesFilter?: number[]
+    resultTypeOutput?: number[]
+    documentGroupFilter?: number[]
+    lcidIgnoreFilter?: number[]
+    lcidFilter?: number[]
+    mrzFormatsFilter?: string[]
+    imageQA?: ImageQA
+    rfidParams?: RFIDParams
+    faceApiParams?: FaceApiParams
+    backendProcessingConfig?: BackendProcessingConfig
+    authenticityParams?: AuthenticityParams
+    customParams?: Record<string, any>
+
+    static fromJson(jsonObject?: any): ProcessParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new ProcessParams
+
+        result.multipageProcessing = jsonObject["multipageProcessing"]
+        result.logs = jsonObject["logs"]
+        result.debugSaveImages = jsonObject["debugSaveImages"]
+        result.debugSaveLogs = jsonObject["debugSaveLogs"]
+        result.returnUncroppedImage = jsonObject["returnUncroppedImage"]
+        result.uvTorchEnabled = jsonObject["uvTorchEnabled"]
+        result.debugSaveCroppedImages = jsonObject["debugSaveCroppedImages"]
+        result.disableFocusingCheck = jsonObject["disableFocusingCheck"]
+        result.debugSaveRFIDSession = jsonObject["debugSaveRFIDSession"]
+        result.doublePageSpread = jsonObject["doublePageSpread"]
+        result.manualCrop = jsonObject["manualCrop"]
+        result.integralImage = jsonObject["integralImage"]
+        result.returnCroppedBarcode = jsonObject["returnCroppedBarcode"]
+        result.checkRequiredTextFields = jsonObject["checkRequiredTextFields"]
+        result.depersonalizeLog = jsonObject["depersonalizeLog"]
+        result.generateDoublePageSpreadImage = jsonObject["generateDoublePageSpreadImage"]
+        result.alreadyCropped = jsonObject["alreadyCropped"]
+        result.matchTextFieldMask = jsonObject["matchTextFieldMask"]
+        result.updateOCRValidityByGlare = jsonObject["updateOCRValidityByGlare"]
+        result.noGraphics = jsonObject["noGraphics"]
+        result.multiDocOnImage = jsonObject["multiDocOnImage"]
+        result.forceReadMrzBeforeLocate = jsonObject["forceReadMrzBeforeLocate"]
+        result.parseBarcodes = jsonObject["parseBarcodes"]
+        result.shouldReturnPackageForReprocess = jsonObject["shouldReturnPackageForReprocess"]
+        result.disablePerforationOCR = jsonObject["disablePerforationOCR"]
+        result.respectImageQuality = jsonObject["respectImageQuality"]
+        result.splitNames = jsonObject["splitNames"]
+        result.useFaceApi = jsonObject["useFaceApi"]
+        result.useAuthenticityCheck = jsonObject["useAuthenticityCheck"]
+        result.checkHologram = jsonObject["checkHologram"]
+        result.barcodeParserType = jsonObject["barcodeParserType"]
+        result.perspectiveAngle = jsonObject["perspectiveAngle"]
+        result.minDPI = jsonObject["minDPI"]
+        result.imageDpiOutMax = jsonObject["imageDpiOutMax"]
+        result.forceDocFormat = jsonObject["forceDocFormat"]
+        result.shiftExpiryDate = jsonObject["shiftExpiryDate"]
+        result.minimalHolderAge = jsonObject["minimalHolderAge"]
+        result.imageOutputMaxHeight = jsonObject["imageOutputMaxHeight"]
+        result.imageOutputMaxWidth = jsonObject["imageOutputMaxWidth"]
+        result.processAuth = jsonObject["processAuth"]
+        result.convertCase = jsonObject["convertCase"]
+        result.measureSystem = jsonObject["measureSystem"]
+        result.forceDocID = jsonObject["forceDocID"]
+        result.dateFormat = jsonObject["dateFormat"]
         result.scenario = jsonObject["scenario"]
-        result.onlineProcessingConfig = OnlineProcessingConfig.fromJson(jsonObject["onlineProcessingConfig"])
-        result.oneShotIdentification = jsonObject["oneShotIdentification"]
-        result.livePortrait = jsonObject["livePortrait"]
-        result.extPortrait = jsonObject["extPortrait"]
-        result.image = jsonObject["image"]
-        result.data = jsonObject["data"]
-        result.images = []
-        if (jsonObject["images"] != null) {
-            for (const i in jsonObject["images"]) {
-                result.images.push(jsonObject["images"][i])
+        result.captureButtonScenario = jsonObject["captureButtonScenario"]
+        result.sessionLogFolder = jsonObject["sessionLogFolder"]
+        result.timeout = jsonObject["timeout"]
+        result.timeoutFromFirstDetect = jsonObject["timeoutFromFirstDetect"]
+        result.timeoutFromFirstDocType = jsonObject["timeoutFromFirstDocType"]
+        result.documentAreaMin = jsonObject["documentAreaMin"]
+        result.documentIDList = []
+        if (jsonObject["documentIDList"] != null) {
+            for (const i in jsonObject["documentIDList"]) {
+                result.documentIDList.push(jsonObject["documentIDList"][i])
             }
         }
-        result.imageInputData = []
-        if (jsonObject["imageInputData"] != null) {
-            for (const i in jsonObject["imageInputData"]) {
-                const item = ImageInputData.fromJson(jsonObject["imageInputData"][i])
-                if (item != undefined)
-                    result.imageInputData.push(item)
+        result.barcodeTypes = []
+        if (jsonObject["barcodeTypes"] != null) {
+            for (const i in jsonObject["barcodeTypes"]) {
+                result.barcodeTypes.push(jsonObject["barcodeTypes"][i])
+            }
+        }
+        result.fieldTypesFilter = []
+        if (jsonObject["fieldTypesFilter"] != null) {
+            for (const i in jsonObject["fieldTypesFilter"]) {
+                result.fieldTypesFilter.push(jsonObject["fieldTypesFilter"][i])
+            }
+        }
+        result.resultTypeOutput = []
+        if (jsonObject["resultTypeOutput"] != null) {
+            for (const i in jsonObject["resultTypeOutput"]) {
+                result.resultTypeOutput.push(jsonObject["resultTypeOutput"][i])
+            }
+        }
+        result.documentGroupFilter = []
+        if (jsonObject["documentGroupFilter"] != null) {
+            for (const i in jsonObject["documentGroupFilter"]) {
+                result.documentGroupFilter.push(jsonObject["documentGroupFilter"][i])
+            }
+        }
+        result.lcidIgnoreFilter = []
+        if (jsonObject["lcidIgnoreFilter"] != null) {
+            for (const i in jsonObject["lcidIgnoreFilter"]) {
+                result.lcidIgnoreFilter.push(jsonObject["lcidIgnoreFilter"][i])
+            }
+        }
+        result.lcidFilter = []
+        if (jsonObject["lcidFilter"] != null) {
+            for (const i in jsonObject["lcidFilter"]) {
+                result.lcidFilter.push(jsonObject["lcidFilter"][i])
+            }
+        }
+        result.mrzFormatsFilter = []
+        if (jsonObject["mrzFormatsFilter"] != null) {
+            for (const i in jsonObject["mrzFormatsFilter"]) {
+                result.mrzFormatsFilter.push(jsonObject["mrzFormatsFilter"][i])
             }
         }
+        result.imageQA = ImageQA.fromJson(jsonObject["imageQA"])
+        result.rfidParams = RFIDParams.fromJson(jsonObject["rfidParams"])
+        result.faceApiParams = FaceApiParams.fromJson(jsonObject["faceApiParams"])
+        result.backendProcessingConfig = BackendProcessingConfig.fromJson(jsonObject["backendProcessingConfig"])
+        result.authenticityParams = AuthenticityParams.fromJson(jsonObject["authenticityParams"])
+        result.customParams = jsonObject["customParams"]
 
         return result
     }
 }
 
-export class License {
-    expiryDate?: string
-    countryFilter?: string[]
-    isRfidAvailable?: boolean
+export class Font {
+    name?: string
+    size?: number
+    style?: number
 
-    static fromJson(jsonObject?: any): License | undefined {
+    static fromJson(jsonObject?: any): Font | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new License
+        const result = new Font
 
-        result.expiryDate = jsonObject["expiryDate"]
-        result.countryFilter = []
-        if (jsonObject["countryFilter"] != null) {
-            for (const i in jsonObject["countryFilter"]) {
-                result.countryFilter.push(jsonObject["countryFilter"][i])
-            }
-        }
-        result.isRfidAvailable = jsonObject["isRfidAvailable"]
+        result.name = jsonObject["name"]
+        result.size = jsonObject["size"]
+        result.style = jsonObject["style"]
 
         return result
     }
 }
 
-export class DocReaderVersion {
-    api?: string
-    core?: string
-    coreMode?: string
-    database?: DocReaderDocumentsDatabase
+export class CustomizationColors {
+    rfidProcessingScreenBackground?: number
+    rfidProcessingScreenHintLabelText?: number
+    rfidProcessingScreenHintLabelBackground?: number
+    rfidProcessingScreenProgressLabelText?: number
+    rfidProcessingScreenProgressBar?: number
+    rfidProcessingScreenProgressBarBackground?: number
+    rfidProcessingScreenResultLabelText?: number
 
-    static fromJson(jsonObject?: any): DocReaderVersion | undefined {
+    static fromJson(jsonObject?: any): CustomizationColors | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new DocReaderVersion
+        const result = new CustomizationColors
 
-        result.api = jsonObject["api"]
-        result.core = jsonObject["core"]
-        result.coreMode = jsonObject["coreMode"]
-        result.database = DocReaderDocumentsDatabase.fromJson(jsonObject["database"])
+        result.rfidProcessingScreenBackground = jsonObject["rfidProcessingScreenBackground"]
+        result.rfidProcessingScreenHintLabelText = jsonObject["rfidProcessingScreenHintLabelText"]
+        result.rfidProcessingScreenHintLabelBackground = jsonObject["rfidProcessingScreenHintLabelBackground"]
+        result.rfidProcessingScreenProgressLabelText = jsonObject["rfidProcessingScreenProgressLabelText"]
+        result.rfidProcessingScreenProgressBar = jsonObject["rfidProcessingScreenProgressBar"]
+        result.rfidProcessingScreenProgressBarBackground = jsonObject["rfidProcessingScreenProgressBarBackground"]
+        result.rfidProcessingScreenResultLabelText = jsonObject["rfidProcessingScreenResultLabelText"]
 
         return result
     }
 }
 
-export class TransactionInfo {
-    transactionId?: string
-    tag?: string
+export class CustomizationFonts {
+    rfidProcessingScreenHintLabel?: Font
+    rfidProcessingScreenProgressLabel?: Font
+    rfidProcessingScreenResultLabel?: Font
 
-    static fromJson(jsonObject?: any): TransactionInfo | undefined {
+    static fromJson(jsonObject?: any): CustomizationFonts | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new TransactionInfo
+        const result = new CustomizationFonts
 
-        result.transactionId = jsonObject["transactionId"]
-        result.tag = jsonObject["tag"]
+        result.rfidProcessingScreenHintLabel = Font.fromJson(jsonObject["rfidProcessingScreenHintLabel"])
+        result.rfidProcessingScreenProgressLabel = Font.fromJson(jsonObject["rfidProcessingScreenProgressLabel"])
+        result.rfidProcessingScreenResultLabel = Font.fromJson(jsonObject["rfidProcessingScreenResultLabel"])
 
         return result
     }
 }
 
-export class DocumentReaderResults {
-    chipPage?: number
-    processingFinishedStatus?: number
-    elapsedTime?: number
-    elapsedTimeRFID?: number
-    morePagesAvailable?: number
-    graphicResult?: DocumentReaderGraphicResult
-    textResult?: DocumentReaderTextResult
-    documentPosition?: ElementPosition[]
-    barcodePosition?: ElementPosition[]
-    mrzPosition?: ElementPosition[]
-    imageQuality?: ImageQualityGroup[]
-    rawResult?: string
-    rfidSessionData?: RFIDSessionData
-    authenticityResult?: DocumentReaderAuthenticityResult
-    barcodeResult?: DocumentReaderBarcodeResult
-    documentType?: DocumentReaderDocumentType[]
-    status?: DocumentReaderResultsStatus
-    vdsncData?: VDSNCData
-    transactionInfo?: TransactionInfo
-
-    textFieldValueByType(fieldType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByType", [this.rawResult, fieldType], successCallback, errorCallback)
-    }
-
-    textFieldValueByTypeLcid(fieldType, lcid, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcid", [this.rawResult, fieldType, lcid], successCallback, errorCallback)
-    }
-
-    textFieldValueByTypeSource(fieldType, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
-    }
+export class CustomizationImages {
+    rfidProcessingScreenFailureImage?: string
 
-    textFieldValueByTypeLcidSource(fieldType, lcid, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcidSource", [this.rawResult, fieldType, lcid, source], successCallback, errorCallback)
-    }
+    static fromJson(jsonObject?: any): CustomizationImages | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new CustomizationImages
 
-    textFieldValueByTypeSourceOriginal(fieldType, source, original, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeSourceOriginal", [this.rawResult, fieldType, source, original], successCallback, errorCallback)
-    }
+        result.rfidProcessingScreenFailureImage = jsonObject["rfidProcessingScreenFailureImage"]
 
-    textFieldValueByTypeLcidSourceOriginal(fieldType, lcid, source, original, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcidSourceOriginal", [this.rawResult, fieldType, lcid, source, original], successCallback, errorCallback)
+        return result
     }
+}
 
-    textFieldByType(fieldType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldByType", [this.rawResult, fieldType], successCallback, errorCallback)
-    }
+export class Customization {
+    showStatusMessages?: boolean
+    showResultStatusMessages?: boolean
+    showHelpAnimation?: boolean
+    showNextPageAnimation?: boolean
+    showBackgroundMask?: boolean
+    cameraFrameBorderWidth?: number
+    cameraFrameLineLength?: number
+    cameraFrameOffsetWidth?: number
+    cameraFrameShapeType?: number
+    status?: string
+    resultStatus?: string
+    cameraFrameDefaultColor?: number
+    cameraFrameActiveColor?: number
+    statusTextColor?: number
+    resultStatusTextColor?: number
+    resultStatusBackgroundColor?: number
+    multipageButtonBackgroundColor?: number
+    tintColor?: number
+    activityIndicatorColor?: number
+    statusBackgroundColor?: number
+    cameraPreviewBackgroundColor?: number
+    statusPositionMultiplier?: number
+    resultStatusPositionMultiplier?: number
+    toolbarSize?: number
+    backgroundMaskAlpha?: number
+    customStatusPositionMultiplier?: number
+    livenessAnimationPositionMultiplier?: number
+    cameraFrameVerticalPositionMultiplier?: number
+    cameraFrameLandscapeAspectRatio?: number
+    cameraFramePortraitAspectRatio?: number
+    cameraFrameCornerRadius?: number
+    multipageAnimationFrontImage?: string
+    multipageAnimationBackImage?: string
+    borderBackgroundImage?: string
+    helpAnimationImage?: string
+    closeButtonImage?: string
+    captureButtonImage?: string
+    cameraSwitchButtonImage?: string
+    torchButtonOnImage?: string
+    torchButtonOffImage?: string
+    changeFrameButtonExpandImage?: string
+    changeFrameButtonCollapseImage?: string
+    livenessAnimationImage?: string
+    statusTextFont?: Font
+    resultStatusTextFont?: Font
+    customLabelStatus?: string
+    cameraFrameLineCap?: number
+    uiCustomizationLayer?: Record<string, any>
+    helpAnimationImageContentMode?: number
+    multipageAnimationFrontImageContentMode?: number
+    multipageAnimationBackImageContentMode?: number
+    livenessAnimationImageContentMode?: number
+    borderBackgroundImageContentMode?: number
+    helpAnimationImageMatrix?: number[]
+    multipageAnimationFrontImageMatrix?: number[]
+    multipageAnimationBackImageMatrix?: number[]
+    livenessAnimationImageMatrix?: number[]
+    borderBackgroundImageMatrix?: number[]
+    colors?: CustomizationColors
+    fonts?: CustomizationFonts
+    images?: CustomizationImages
+
+    static fromJson(jsonObject?: any): Customization | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new Customization
+
+        result.showStatusMessages = jsonObject["showStatusMessages"]
+        result.showResultStatusMessages = jsonObject["showResultStatusMessages"]
+        result.showHelpAnimation = jsonObject["showHelpAnimation"]
+        result.showNextPageAnimation = jsonObject["showNextPageAnimation"]
+        result.showBackgroundMask = jsonObject["showBackgroundMask"]
+        result.cameraFrameBorderWidth = jsonObject["cameraFrameBorderWidth"]
+        result.cameraFrameLineLength = jsonObject["cameraFrameLineLength"]
+        result.cameraFrameOffsetWidth = jsonObject["cameraFrameOffsetWidth"]
+        result.cameraFrameShapeType = jsonObject["cameraFrameShapeType"]
+        result.status = jsonObject["status"]
+        result.resultStatus = jsonObject["resultStatus"]
+        result.cameraFrameDefaultColor = jsonObject["cameraFrameDefaultColor"]
+        result.cameraFrameActiveColor = jsonObject["cameraFrameActiveColor"]
+        result.statusTextColor = jsonObject["statusTextColor"]
+        result.resultStatusTextColor = jsonObject["resultStatusTextColor"]
+        result.resultStatusBackgroundColor = jsonObject["resultStatusBackgroundColor"]
+        result.multipageButtonBackgroundColor = jsonObject["multipageButtonBackgroundColor"]
+        result.tintColor = jsonObject["tintColor"]
+        result.activityIndicatorColor = jsonObject["activityIndicatorColor"]
+        result.statusBackgroundColor = jsonObject["statusBackgroundColor"]
+        result.cameraPreviewBackgroundColor = jsonObject["cameraPreviewBackgroundColor"]
+        result.statusPositionMultiplier = jsonObject["statusPositionMultiplier"]
+        result.resultStatusPositionMultiplier = jsonObject["resultStatusPositionMultiplier"]
+        result.toolbarSize = jsonObject["toolbarSize"]
+        result.backgroundMaskAlpha = jsonObject["backgroundMaskAlpha"]
+        result.customStatusPositionMultiplier = jsonObject["customStatusPositionMultiplier"]
+        result.livenessAnimationPositionMultiplier = jsonObject["livenessAnimationPositionMultiplier"]
+        result.cameraFrameVerticalPositionMultiplier = jsonObject["cameraFrameVerticalPositionMultiplier"]
+        result.cameraFrameLandscapeAspectRatio = jsonObject["cameraFrameLandscapeAspectRatio"]
+        result.cameraFramePortraitAspectRatio = jsonObject["cameraFramePortraitAspectRatio"]
+        result.cameraFrameCornerRadius = jsonObject["cameraFrameCornerRadius"]
+        result.multipageAnimationFrontImage = jsonObject["multipageAnimationFrontImage"]
+        result.multipageAnimationBackImage = jsonObject["multipageAnimationBackImage"]
+        result.borderBackgroundImage = jsonObject["borderBackgroundImage"]
+        result.helpAnimationImage = jsonObject["helpAnimationImage"]
+        result.closeButtonImage = jsonObject["closeButtonImage"]
+        result.captureButtonImage = jsonObject["captureButtonImage"]
+        result.cameraSwitchButtonImage = jsonObject["cameraSwitchButtonImage"]
+        result.torchButtonOnImage = jsonObject["torchButtonOnImage"]
+        result.torchButtonOffImage = jsonObject["torchButtonOffImage"]
+        result.changeFrameButtonExpandImage = jsonObject["changeFrameButtonExpandImage"]
+        result.changeFrameButtonCollapseImage = jsonObject["changeFrameButtonCollapseImage"]
+        result.livenessAnimationImage = jsonObject["livenessAnimationImage"]
+        result.statusTextFont = Font.fromJson(jsonObject["statusTextFont"])
+        result.resultStatusTextFont = Font.fromJson(jsonObject["resultStatusTextFont"])
+        result.customLabelStatus = jsonObject["customLabelStatus"]
+        result.cameraFrameLineCap = jsonObject["cameraFrameLineCap"]
+        result.uiCustomizationLayer = jsonObject["uiCustomizationLayer"]
+        result.helpAnimationImageContentMode = jsonObject["helpAnimationImageContentMode"]
+        result.multipageAnimationFrontImageContentMode = jsonObject["multipageAnimationFrontImageContentMode"]
+        result.multipageAnimationBackImageContentMode = jsonObject["multipageAnimationBackImageContentMode"]
+        result.livenessAnimationImageContentMode = jsonObject["livenessAnimationImageContentMode"]
+        result.borderBackgroundImageContentMode = jsonObject["borderBackgroundImageContentMode"]
+        result.helpAnimationImageMatrix = []
+        if (jsonObject["helpAnimationImageMatrix"] != null) {
+            for (const i in jsonObject["helpAnimationImageMatrix"]) {
+                result.helpAnimationImageMatrix.push(jsonObject["helpAnimationImageMatrix"][i])
+            }
+        }
+        result.multipageAnimationFrontImageMatrix = []
+        if (jsonObject["multipageAnimationFrontImageMatrix"] != null) {
+            for (const i in jsonObject["multipageAnimationFrontImageMatrix"]) {
+                result.multipageAnimationFrontImageMatrix.push(jsonObject["multipageAnimationFrontImageMatrix"][i])
+            }
+        }
+        result.multipageAnimationBackImageMatrix = []
+        if (jsonObject["multipageAnimationBackImageMatrix"] != null) {
+            for (const i in jsonObject["multipageAnimationBackImageMatrix"]) {
+                result.multipageAnimationBackImageMatrix.push(jsonObject["multipageAnimationBackImageMatrix"][i])
+            }
+        }
+        result.livenessAnimationImageMatrix = []
+        if (jsonObject["livenessAnimationImageMatrix"] != null) {
+            for (const i in jsonObject["livenessAnimationImageMatrix"]) {
+                result.livenessAnimationImageMatrix.push(jsonObject["livenessAnimationImageMatrix"][i])
+            }
+        }
+        result.borderBackgroundImageMatrix = []
+        if (jsonObject["borderBackgroundImageMatrix"] != null) {
+            for (const i in jsonObject["borderBackgroundImageMatrix"]) {
+                result.borderBackgroundImageMatrix.push(jsonObject["borderBackgroundImageMatrix"][i])
+            }
+        }
+        result.colors = CustomizationColors.fromJson(jsonObject["colors"])
+        result.fonts = CustomizationFonts.fromJson(jsonObject["fonts"])
+        result.images = CustomizationImages.fromJson(jsonObject["images"])
 
-    textFieldByTypeLcid(fieldType, lcid, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldByTypeLcid", [this.rawResult, fieldType, lcid], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldByTypeSource(fieldType, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
-    }
+export class EDLDataGroups {
+    DG1?: boolean
+    DG2?: boolean
+    DG3?: boolean
+    DG4?: boolean
+    DG5?: boolean
+    DG6?: boolean
+    DG7?: boolean
+    DG8?: boolean
+    DG9?: boolean
+    DG10?: boolean
+    DG11?: boolean
+    DG12?: boolean
+    DG13?: boolean
+    DG14?: boolean
+
+    static fromJson(jsonObject?: any): EDLDataGroups | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new EDLDataGroups
+
+        result.DG1 = jsonObject["DG1"]
+        result.DG2 = jsonObject["DG2"]
+        result.DG3 = jsonObject["DG3"]
+        result.DG4 = jsonObject["DG4"]
+        result.DG5 = jsonObject["DG5"]
+        result.DG6 = jsonObject["DG6"]
+        result.DG7 = jsonObject["DG7"]
+        result.DG8 = jsonObject["DG8"]
+        result.DG9 = jsonObject["DG9"]
+        result.DG10 = jsonObject["DG10"]
+        result.DG11 = jsonObject["DG11"]
+        result.DG12 = jsonObject["DG12"]
+        result.DG13 = jsonObject["DG13"]
+        result.DG14 = jsonObject["DG14"]
 
-    graphicFieldByTypeSourcePageIndex(fieldType, source, pageIndex, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldByTypeSourcePageIndexLight(fieldType, source, pageIndex, light, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex, light], successCallback, errorCallback)
-    }
+export class EPassportDataGroups {
+    DG1?: boolean
+    DG2?: boolean
+    DG3?: boolean
+    DG4?: boolean
+    DG5?: boolean
+    DG6?: boolean
+    DG7?: boolean
+    DG8?: boolean
+    DG9?: boolean
+    DG10?: boolean
+    DG11?: boolean
+    DG12?: boolean
+    DG13?: boolean
+    DG14?: boolean
+    DG15?: boolean
+    DG16?: boolean
+
+    static fromJson(jsonObject?: any): EPassportDataGroups | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new EPassportDataGroups
+
+        result.DG1 = jsonObject["DG1"]
+        result.DG2 = jsonObject["DG2"]
+        result.DG3 = jsonObject["DG3"]
+        result.DG4 = jsonObject["DG4"]
+        result.DG5 = jsonObject["DG5"]
+        result.DG6 = jsonObject["DG6"]
+        result.DG7 = jsonObject["DG7"]
+        result.DG8 = jsonObject["DG8"]
+        result.DG9 = jsonObject["DG9"]
+        result.DG10 = jsonObject["DG10"]
+        result.DG11 = jsonObject["DG11"]
+        result.DG12 = jsonObject["DG12"]
+        result.DG13 = jsonObject["DG13"]
+        result.DG14 = jsonObject["DG14"]
+        result.DG15 = jsonObject["DG15"]
+        result.DG16 = jsonObject["DG16"]
 
-    graphicFieldImageByType(fieldType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByType", [this.rawResult, fieldType], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldImageByTypeSource(fieldType, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
-    }
+export class EIDDataGroups {
+    DG1?: boolean
+    DG2?: boolean
+    DG3?: boolean
+    DG4?: boolean
+    DG5?: boolean
+    DG6?: boolean
+    DG7?: boolean
+    DG8?: boolean
+    DG9?: boolean
+    DG10?: boolean
+    DG11?: boolean
+    DG12?: boolean
+    DG13?: boolean
+    DG14?: boolean
+    DG15?: boolean
+    DG16?: boolean
+    DG17?: boolean
+    DG18?: boolean
+    DG19?: boolean
+    DG20?: boolean
+    DG21?: boolean
+
+    static fromJson(jsonObject?: any): EIDDataGroups | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new EIDDataGroups
+
+        result.DG1 = jsonObject["DG1"]
+        result.DG2 = jsonObject["DG2"]
+        result.DG3 = jsonObject["DG3"]
+        result.DG4 = jsonObject["DG4"]
+        result.DG5 = jsonObject["DG5"]
+        result.DG6 = jsonObject["DG6"]
+        result.DG7 = jsonObject["DG7"]
+        result.DG8 = jsonObject["DG8"]
+        result.DG9 = jsonObject["DG9"]
+        result.DG10 = jsonObject["DG10"]
+        result.DG11 = jsonObject["DG11"]
+        result.DG12 = jsonObject["DG12"]
+        result.DG13 = jsonObject["DG13"]
+        result.DG14 = jsonObject["DG14"]
+        result.DG15 = jsonObject["DG15"]
+        result.DG16 = jsonObject["DG16"]
+        result.DG17 = jsonObject["DG17"]
+        result.DG18 = jsonObject["DG18"]
+        result.DG19 = jsonObject["DG19"]
+        result.DG20 = jsonObject["DG20"]
+        result.DG21 = jsonObject["DG21"]
 
-    graphicFieldImageByTypeSourcePageIndex(fieldType, source, pageIndex, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldImageByTypeSourcePageIndexLight(fieldType, source, pageIndex, light, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSourcePageIndexLight", [this.rawResult, fieldType, source, pageIndex, light], successCallback, errorCallback)
-    }
+export class RFIDScenario {
+    paceStaticBinding?: boolean
+    onlineTA?: boolean
+    writeEid?: boolean
+    universalAccessRights?: boolean
+    authorizedRestrictedIdentification?: boolean
+    auxVerificationCommunityID?: boolean
+    auxVerificationDateOfBirth?: boolean
+    skipAA?: boolean
+    strictProcessing?: boolean
+    pkdDSCertPriority?: boolean
+    pkdUseExternalCSCA?: boolean
+    trustedPKD?: boolean
+    passiveAuth?: boolean
+    useSFI?: boolean
+    readEPassport?: boolean
+    readEID?: boolean
+    readEDL?: boolean
+    authorizedSTSignature?: boolean
+    authorizedSTQSignature?: boolean
+    authorizedWriteDG17?: boolean
+    authorizedWriteDG18?: boolean
+    authorizedWriteDG19?: boolean
+    authorizedWriteDG20?: boolean
+    authorizedWriteDG21?: boolean
+    authorizedVerifyAge?: boolean
+    authorizedVerifyCommunityID?: boolean
+    authorizedPrivilegedTerminal?: boolean
+    authorizedCANAllowed?: boolean
+    authorizedPINManagement?: boolean
+    authorizedInstallCert?: boolean
+    authorizedInstallQCert?: boolean
+    applyAmendments?: boolean
+    autoSettings?: boolean
+    proceedReadingAlways?: boolean
+    readingBuffer?: number
+    onlineTAToSignDataType?: number
+    defaultReadingBufferSize?: number
+    signManagementAction?: number
+    profilerType?: number
+    authProcType?: number
+    baseSMProcedure?: number
+    pacePasswordType?: number
+    terminalType?: number
+    password?: string
+    pkdPA?: string
+    pkdEAC?: string
+    mrz?: string
+    eSignPINDefault?: string
+    eSignPINNewValue?: string
+    eDLDataGroups?: EDLDataGroups
+    ePassportDataGroups?: EPassportDataGroups
+    eIDDataGroups?: EIDDataGroups
+
+    static fromJson(jsonObject?: any): RFIDScenario | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new RFIDScenario
+
+        result.paceStaticBinding = jsonObject["paceStaticBinding"]
+        result.onlineTA = jsonObject["onlineTA"]
+        result.writeEid = jsonObject["writeEid"]
+        result.universalAccessRights = jsonObject["universalAccessRights"]
+        result.authorizedRestrictedIdentification = jsonObject["authorizedRestrictedIdentification"]
+        result.auxVerificationCommunityID = jsonObject["auxVerificationCommunityID"]
+        result.auxVerificationDateOfBirth = jsonObject["auxVerificationDateOfBirth"]
+        result.skipAA = jsonObject["skipAA"]
+        result.strictProcessing = jsonObject["strictProcessing"]
+        result.pkdDSCertPriority = jsonObject["pkdDSCertPriority"]
+        result.pkdUseExternalCSCA = jsonObject["pkdUseExternalCSCA"]
+        result.trustedPKD = jsonObject["trustedPKD"]
+        result.passiveAuth = jsonObject["passiveAuth"]
+        result.useSFI = jsonObject["useSFI"]
+        result.readEPassport = jsonObject["readEPassport"]
+        result.readEID = jsonObject["readEID"]
+        result.readEDL = jsonObject["readEDL"]
+        result.authorizedSTSignature = jsonObject["authorizedSTSignature"]
+        result.authorizedSTQSignature = jsonObject["authorizedSTQSignature"]
+        result.authorizedWriteDG17 = jsonObject["authorizedWriteDG17"]
+        result.authorizedWriteDG18 = jsonObject["authorizedWriteDG18"]
+        result.authorizedWriteDG19 = jsonObject["authorizedWriteDG19"]
+        result.authorizedWriteDG20 = jsonObject["authorizedWriteDG20"]
+        result.authorizedWriteDG21 = jsonObject["authorizedWriteDG21"]
+        result.authorizedVerifyAge = jsonObject["authorizedVerifyAge"]
+        result.authorizedVerifyCommunityID = jsonObject["authorizedVerifyCommunityID"]
+        result.authorizedPrivilegedTerminal = jsonObject["authorizedPrivilegedTerminal"]
+        result.authorizedCANAllowed = jsonObject["authorizedCANAllowed"]
+        result.authorizedPINManagement = jsonObject["authorizedPINManagement"]
+        result.authorizedInstallCert = jsonObject["authorizedInstallCert"]
+        result.authorizedInstallQCert = jsonObject["authorizedInstallQCert"]
+        result.applyAmendments = jsonObject["applyAmendments"]
+        result.autoSettings = jsonObject["autoSettings"]
+        result.proceedReadingAlways = jsonObject["proceedReadingAlways"]
+        result.readingBuffer = jsonObject["readingBuffer"]
+        result.onlineTAToSignDataType = jsonObject["onlineTAToSignDataType"]
+        result.defaultReadingBufferSize = jsonObject["defaultReadingBufferSize"]
+        result.signManagementAction = jsonObject["signManagementAction"]
+        result.profilerType = jsonObject["profilerType"]
+        result.authProcType = jsonObject["authProcType"]
+        result.baseSMProcedure = jsonObject["baseSMProcedure"]
+        result.pacePasswordType = jsonObject["pacePasswordType"]
+        result.terminalType = jsonObject["terminalType"]
+        result.password = jsonObject["password"]
+        result.pkdPA = jsonObject["pkdPA"]
+        result.pkdEAC = jsonObject["pkdEAC"]
+        result.mrz = jsonObject["mrz"]
+        result.eSignPINDefault = jsonObject["eSignPINDefault"]
+        result.eSignPINNewValue = jsonObject["eSignPINNewValue"]
+        result.eDLDataGroups = EDLDataGroups.fromJson(jsonObject["eDLDataGroups"])
+        result.ePassportDataGroups = EPassportDataGroups.fromJson(jsonObject["ePassportDataGroups"])
+        result.eIDDataGroups = EIDDataGroups.fromJson(jsonObject["eIDDataGroups"])
 
-    containers(resultType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "containers", [this.rawResult, resultType], successCallback, errorCallback)
+        return result
     }
+}
 
-    encryptedContainers(successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "encryptedContainers", [this.rawResult], successCallback, errorCallback)
-    }
+export class PrepareProgress {
+    downloadedBytes?: number
+    totalBytes?: number
+    progress?: number
 
-    static fromJson(jsonObject?: any): DocumentReaderResults | undefined {
+    static fromJson(jsonObject?: any): PrepareProgress | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new DocumentReaderResults
+        const result = new PrepareProgress
 
-        result.chipPage = jsonObject["chipPage"]
-        result.processingFinishedStatus = jsonObject["processingFinishedStatus"]
-        result.elapsedTime = jsonObject["elapsedTime"]
-        result.elapsedTimeRFID = jsonObject["elapsedTimeRFID"]
-        result.morePagesAvailable = jsonObject["morePagesAvailable"]
-        result.graphicResult = DocumentReaderGraphicResult.fromJson(jsonObject["graphicResult"])
-        result.textResult = DocumentReaderTextResult.fromJson(jsonObject["textResult"])
-        result.documentPosition = []
-        if (jsonObject["documentPosition"] != null) {
-            for (const i in jsonObject["documentPosition"]) {
-                const item = ElementPosition.fromJson(jsonObject["documentPosition"][i])
-                if (item != undefined)
-                    result.documentPosition.push(item)
-            }
-        }
-        result.barcodePosition = []
-        if (jsonObject["barcodePosition"] != null) {
-            for (const i in jsonObject["barcodePosition"]) {
-                const item = ElementPosition.fromJson(jsonObject["barcodePosition"][i])
-                if (item != undefined)
-                    result.barcodePosition.push(item)
-            }
-        }
-        result.mrzPosition = []
-        if (jsonObject["mrzPosition"] != null) {
-            for (const i in jsonObject["mrzPosition"]) {
-                const item = ElementPosition.fromJson(jsonObject["mrzPosition"][i])
-                if (item != undefined)
-                    result.mrzPosition.push(item)
-            }
-        }
-        result.imageQuality = []
-        if (jsonObject["imageQuality"] != null) {
-            for (const i in jsonObject["imageQuality"]) {
-                const item = ImageQualityGroup.fromJson(jsonObject["imageQuality"][i])
-                if (item != undefined)
-                    result.imageQuality.push(item)
-            }
-        }
-        result.rawResult = jsonObject["rawResult"]
-        result.rfidSessionData = RFIDSessionData.fromJson(jsonObject["rfidSessionData"])
-        result.authenticityResult = DocumentReaderAuthenticityResult.fromJson(jsonObject["authenticityResult"])
-        result.barcodeResult = DocumentReaderBarcodeResult.fromJson(jsonObject["barcodeResult"])
-        result.documentType = []
-        if (jsonObject["documentType"] != null) {
-            for (const i in jsonObject["documentType"]) {
-                const item = DocumentReaderDocumentType.fromJson(jsonObject["documentType"][i])
-                if (item != undefined)
-                    result.documentType.push(item)
-            }
-        }
-        result.status = DocumentReaderResultsStatus.fromJson(jsonObject["status"])
-        result.vdsncData = VDSNCData.fromJson(jsonObject["vdsncData"])
-        result.transactionInfo = TransactionInfo.fromJson(jsonObject["transactionInfo"])
+        result.downloadedBytes = jsonObject["downloadedBytes"]
+        result.totalBytes = jsonObject["totalBytes"]
+        result.progress = jsonObject["progress"]
 
         return result
     }
@@ -2336,11 +3104,6 @@ export const eRPRM_ResultType = {
     RPRM_RESULT_TYPE_EXT_PORTRAIT: 35,
 }
 
-export const CameraTypes = {
-    FRONT: "front",
-    BACK: "back",
-}
-
 export const FrameShapeType = {
     LINE: 0,
     CORNER: 1,
@@ -2353,6 +3116,12 @@ export const eRFID_BaudRate = {
     rfbr_848: 8,
 }
 
+export const LineCap = {
+    BUTT: 0,
+    ROUND: 1,
+    SQUARE: 2,
+}
+
 export const eRPRM_FieldVerificationResult = {
     RCF_DISABLED: 0,
     RCF_VERIFIED: 1,
@@ -2458,6 +3227,11 @@ export const DocumentReaderErrorCodes = {
     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,
     NATIVE_JAVA_EXCEPTION: 1000,
     BACKEND_ONLINE_PROCESSING: 303,
     WRONG_INPUT: 400,
@@ -2540,6 +3314,12 @@ export const eRFID_NotificationCodes = {
     RFID_NOTIFICATION_BIOMETRICS_EMPTY_PLACEHOLDER: 0x000F0000,
 }
 
+export const CameraPosition = {
+    UNSPECIFIED: 0,
+    BACK: 1,
+    FRONT: 2,
+}
+
 export const eRFID_Password_Type = {
     PPT_UNKNOWN: 0,
     PPT_MRZ: 1,
@@ -2550,6 +3330,23 @@ export const eRFID_Password_Type = {
     PPT_SAI: 6,
 }
 
+export const ViewContentMode = {
+    UNKNOWN: -1,
+    SCALE_TO_FILL: 0,
+    SCALE_ASPECT_FIT: 1,
+    SCALE_ASPECT_FILL: 2,
+    REDRAW: 3,
+    CENTER: 4,
+    TOP: 5,
+    BOTTOM: 6,
+    LEFT: 7,
+    RIGHT: 8,
+    TOP_LEFT: 9,
+    TOP_RIGHT: 10,
+    BOTTOM_LEFT: 11,
+    BOTTOM_RIGHT: 12,
+}
+
 export const BarcodeResult = {
     NO_ERR: 0,
     NULL_PTR_ERR: -6001,
@@ -2704,6 +3501,12 @@ export const eCheckDiagnose = {
     LAS_INK_INVALID_LINES_FREQUENCY: 230,
     DOC_LIVENESS_ELECTRONIC_DEVICE_DETECTED: 240,
     DOC_LIVENESS_INVALID_BARCODE_BACKGROUND: 241,
+    ICAO_IDB_BASE_32_ERROR: 243,
+    ICAO_IDB_ZIPPED_ERROR: 244,
+    ICAO_IDB_MESSAGE_ZONE_EMPTY: 245,
+    ICAO_IDB_SIGNATURE_MUST_BE_PRESENT: 246,
+    ICAO_IDB_SIGNATURE_MUST_NOT_BE_PRESENT: 247,
+    ICAO_IDB_CERTIFICATE_MUST_NOT_BE_PRESENT: 248,
     LAST_DIAGNOSE_VALUE: 250,
 }
 
@@ -2978,6 +3781,10 @@ export const eLDS_ParsingNotificationCodes = {
     NTF_LDS_AUTH_ML_SIGNER_INFO_CERTIFICATE_CANT_FIND_CSCA: 0x92000117,
     NTF_LDS_AUTH_ML_SIGNER_INFO_CERTIFICATE_REVOKED: 0x92000118,
     NTF_LDS_AUTH_ML_SIGNER_INFO_CERTIFICATE_SIGNATURE_INVALID: 0x92000119,
+    NTF_LDS_ICAO_CERTIFICATE_CHAIN_COUNTRY_NON_MATCHING: 0x90000250,
+    NTF_LDS_ICAO_CERTIFICATE_VISUAL_MRZ_COUNTRY_NON_MATCHING: 0x90000251,
+    NTF_LDS_MRZ_COUNTRYCODE_VISUALMRZ_NON_MATCHING: 0x00022019,
+    NTF_LDS_ICAO_CERTIFICATE_MRZ_COUNTRY_NON_MATCHING: 0x90000252,
 }
 
 export const eImageQualityCheckType = {
@@ -3391,6 +4198,22 @@ export const RegDeviceConfigType = {
     DEVICE_7310: "DEVICE_7310",
 }
 
+export const CaptureSessionPreset = {
+    UNKNOWN: -1,
+    LOW: 0,
+    MEDIUM: 1,
+    HIGH: 2,
+    PHOTO: 3,
+    INPUT_PRIORITY: 4,
+    PRESET_1280x720: 6,
+    PRESET_1920x1080: 7,
+    PRESET_3840x2160: 8,
+    FRAME_960x540: 9,
+    FRAME_1280x720: 10,
+    PRESET_640x480: 12,
+    PRESET_352x288: 13,
+}
+
 export const CameraMode = {
     AUTO: 0,
     CAMERA1: 1,
@@ -4138,6 +4961,7 @@ export const eVisualFieldType = {
     FT_ADDRESS_BUILDING_TYPE: 680,
     FT_DATE_OF_RETIREMENT: 681,
     FT_DOCUMENT_STATUS: 682,
+    FT_SIGNATURE: 683,
 }
 
 export const DocReaderOrientation = {
@@ -4340,61 +5164,6 @@ export const eRPRM_Lights = {
     RPRM_LIGHT_WHITE_FULL_OVD: (6 | 67108864),
 }
 
-export const LineCap = {
-    Butt: 0,
-    Round: 1,
-    Square: 2,
-}
-
-export const UIInterfaceOrientationMask = {
-    Portrait: 0,
-    LandscapeLeft: 1,
-    LandscapeRight: 2,
-    PortraitUpsideDown: 3,
-    Landscape: 4,
-    All: 5,
-    AllButUpsideDown: 6,
-}
-
-export const AVCaptureSessionPreset = {
-    Low: 0,
-    Medium: 1,
-    High: 2,
-    Photo: 3,
-    InputPriority: 4,
-    QHD960x540: 5,
-    Hd1280x720: 6,
-    Hd1920x1080: 7,
-    Hd4K3840x2160: 8,
-    IFrame960x540: 9,
-    IFrame1280x720: 10,
-    Qvga320x240: 11,
-    Vga640x480: 12,
-    Cif352x288: 13,
-}
-
-export const AVCaptureDevicePosition = {
-    Front: 0,
-    Back: 1,
-    Unspecified: 2,
-}
-
-export const UIViewContentMode = {
-    ScaleToFill: 0,
-    ScaleAspectFit: 1,
-    ScaleAspectFill: 2,
-    Redraw: 3,
-    Center: 4,
-    Top: 5,
-    Bottom: 6,
-    Left: 7,
-    Right: 8,
-    TopLeft: 9,
-    TopRight: 10,
-    BottomLeft: 11,
-    BottomRight: 12,
-}
-
 export const Enum = {
    FontStyle,
    eRPRM_Authenticity,
@@ -4404,9 +5173,9 @@ export const Enum = {
    eRFID_CertificateType,
    RGLMeasureSystem,
    eRPRM_ResultType,
-   CameraTypes,
    FrameShapeType,
    eRFID_BaudRate,
+   LineCap,
    eRPRM_FieldVerificationResult,
    DocReaderAction,
    eProcessGLCommands,
@@ -4416,7 +5185,9 @@ export const Enum = {
    ScenarioIdentifier,
    eRFID_AccessControl_ProcedureType,
    eRFID_NotificationCodes,
+   CameraPosition,
    eRFID_Password_Type,
+   ViewContentMode,
    BarcodeResult,
    eSignManagementAction,
    eCheckDiagnose,
@@ -4440,6 +5211,7 @@ export const Enum = {
    ImageFormat,
    eGraphicFieldType,
    RegDeviceConfigType,
+   CaptureSessionPreset,
    CameraMode,
    CaptureMode,
    eCheckResult,
@@ -4451,11 +5223,6 @@ export const Enum = {
    CustomizationImage,
    DocReaderFrame,
    eRPRM_Lights,
-   LineCap,
-   UIInterfaceOrientationMask,
-   AVCaptureSessionPreset,
-   AVCaptureDevicePosition,
-   UIViewContentMode,
 }
 
 export default class DocumentReader {
@@ -4466,44 +5233,45 @@ export default class DocumentReader {
     static getRfidSessionStatus(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static setRfidSessionStatus(status: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getTag(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setTag(tag: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setTag(tag: string | null, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getFunctionality(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setFunctionality(functionality: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setFunctionality(functionality: Functionality, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getProcessParams(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setProcessParams(processParams: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setProcessParams(processParams: ProcessParams, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getCustomization(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setCustomization(customization: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setCustomization(customization: Customization, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getRfidScenario(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setRfidScenario(rfidScenario: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static initializeReader(config: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static initializeReaderWithBleDeviceConfig(config: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setRfidScenario(rfidScenario: RFIDScenario, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static resetConfiguration(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static initializeReader(config: DocReaderConfig, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static initializeReaderWithBleDeviceConfig(config: DocReaderConfig, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static deinitializeReader(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static prepareDatabase(databaseType: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static removeDatabase(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static runAutoUpdate(databaseId: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static cancelDBUpdate(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static checkDatabaseUpdate(databaseId: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static scan(config: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static recognize(config: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static scan(config: ScannerConfig, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static recognize(config: RecognizeConfig, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static startNewPage(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static stopScanner(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static startRFIDReader(requestPACertificates: boolean, requestTACertificates: boolean, requestTASignature: boolean, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static stopRFIDReader(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static readRFID(requestPACertificates: boolean, requestTACertificates: boolean, requestTASignature: boolean, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static providePACertificates(certificates: PKDCertificate[], successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static provideTACertificates(certificates: PKDCertificate[], successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static stopRFIDReader(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static providePACertificates(certificates: PKDCertificate[] | null, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static provideTACertificates(certificates: PKDCertificate[] | null, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static provideTASignature(signature: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setTCCParams(params: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setTCCParams(params: TccParams, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static addPKDCertificates(certificates: PKDCertificate[], successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static clearPKDCertificates(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static startNewSession(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static startBluetoothService(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setLocalizationDictionary(dictionary: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static setLocalizationDictionary(dictionary: Record<string, string>, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getLicense(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getAvailableScenarios(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getIsRFIDAvailableForUse(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getDocReaderVersion(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getDocReaderDocumentsDatabase(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getTranslation(className: string, value: number, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static finalizePackage(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static getTranslation(className: string, value: number, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
 }