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

package/index.d.ts

@@ -57,25 +57,6 @@ export class Rect {
     }
 }
 
-export class DocReaderFieldRect {
-    bottom?: number
-    top?: number
-    left?: number
-    right?: number
-
-    static fromJson(jsonObject?: any): DocReaderFieldRect | undefined {
-        if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new DocReaderFieldRect
-
-        result.bottom = jsonObject["bottom"]
-        result.top = jsonObject["top"]
-        result.left = jsonObject["left"]
-        result.right = jsonObject["right"]
-
-        return result
-    }
-}
-
 export class DocumentReaderGraphicField {
     sourceType?: number
     fieldType?: number
@@ -85,7 +66,7 @@ export class DocumentReaderGraphicField {
     fieldName?: string
     lightName?: string
     value?: string
-    fieldRect?: DocReaderFieldRect
+    fieldRect?: Rect
 
     static fromJson(jsonObject?: any): DocumentReaderGraphicField | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
@@ -99,7 +80,7 @@ export class DocumentReaderGraphicField {
         result.fieldName = jsonObject["fieldName"]
         result.lightName = jsonObject["lightName"]
         result.value = jsonObject["value"]
-        result.fieldRect = DocReaderFieldRect.fromJson(jsonObject["fieldRect"])
+        result.fieldRect = Rect.fromJson(jsonObject["fieldRect"])
 
         return result
     }
@@ -128,12 +109,10 @@ export class DocumentReaderGraphicResult {
 export class DocumentReaderValue {
     pageIndex?: number
     sourceType?: number
-    validity?: number
     probability?: number
     value?: string
     originalValue?: string
     boundRect?: Rect
-    comparison?: Record<number, number>
     originalSymbols?: DocumentReaderSymbol[]
     rfidOrigin?: DocumentReaderRfidOrigin
 
@@ -143,17 +122,10 @@ export class DocumentReaderValue {
 
         result.pageIndex = jsonObject["pageIndex"]
         result.sourceType = jsonObject["sourceType"]
-        result.validity = jsonObject["validity"]
         result.probability = jsonObject["probability"]
         result.value = jsonObject["value"]
         result.originalValue = jsonObject["originalValue"]
         result.boundRect = Rect.fromJson(jsonObject["boundRect"])
-        result.comparison = {}
-        if (jsonObject["comparison"] != null) {
-            for (const i in jsonObject["comparison"]) {
-                result.comparison[i as unknown as number] = jsonObject["comparison"][i]
-            }
-        }
         result.originalSymbols = []
         if (jsonObject["originalSymbols"] != null) {
             for (const i in jsonObject["originalSymbols"]) {
@@ -321,6 +293,7 @@ export class ImageQuality {
     featureType?: number
     result?: number
     type?: number
+    boundRects?: Rect[]
 
     static fromJson(jsonObject?: any): ImageQuality | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
@@ -329,6 +302,14 @@ export class ImageQuality {
         result.featureType = jsonObject["featureType"]
         result.result = jsonObject["result"]
         result.type = jsonObject["type"]
+        result.boundRects = []
+        if (jsonObject["boundRects"] != null) {
+            for (const i in jsonObject["boundRects"]) {
+                const item = Rect.fromJson(jsonObject["boundRects"][i])
+                if (item != undefined)
+                    result.boundRects.push(item)
+            }
+        }
 
         return result
     }
@@ -491,6 +472,7 @@ export class SecurityObjectCertificates {
 export class File {
     readingTime?: number
     type?: number
+    typeName?: string
     pAStatus?: number
     readingStatus?: number
     fileID?: string
@@ -507,6 +489,7 @@ export class File {
 
         result.readingTime = jsonObject["readingTime"]
         result.type = jsonObject["type"]
+        result.typeName = jsonObject["typeName"]
         result.pAStatus = jsonObject["pAStatus"]
         result.readingStatus = jsonObject["readingStatus"]
         result.fileID = jsonObject["fileID"]
@@ -989,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
@@ -999,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
     }
@@ -1117,6 +1095,27 @@ export class PKDCertificate {
     }
 }
 
+export class TccParams {
+    serviceUrlTA?: string
+    serviceUrlPA?: string
+    pfxCertUrl?: string
+    pfxPassPhrase?: string
+    pfxCert?: string
+
+    static fromJson(jsonObject?: any): TccParams | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new TccParams
+
+        result.serviceUrlTA = jsonObject["serviceUrlTA"]
+        result.serviceUrlPA = jsonObject["serviceUrlPA"]
+        result.pfxCertUrl = jsonObject["pfxCertUrl"]
+        result.pfxPassPhrase = jsonObject["pfxPassPhrase"]
+        result.pfxCert = jsonObject["pfxCert"]
+
+        return result
+    }
+}
+
 export class ImageInputParam {
     width?: number
     height?: number
@@ -1139,7 +1138,7 @@ export class ImageInputParam {
 }
 
 export class PAResourcesIssuer {
-    data?: any[]
+    data?: string
     friendlyName?: string
     attributes?: PAAttribute[]
 
@@ -1147,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) {
@@ -1183,7 +1177,7 @@ export class PAAttribute {
 }
 
 export class TAChallenge {
-    data?: any[]
+    data?: string
     auxPCD?: string
     challengePICC?: string
     hashPK?: string
@@ -1193,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"]
@@ -1291,7 +1280,7 @@ export class VDSNCData {
     type?: string
     version?: number
     issuingCountry?: string
-    message?: any
+    message?: Record<string, any>
     signatureAlgorithm?: string
     signature?: BytesData
     certificate?: BytesData
@@ -1354,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
@@ -1366,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
     }
@@ -1487,50 +1471,423 @@ export class DocumentReaderValidity {
     }
 }
 
-export class FaceApiParams {
+export class OnlineProcessingConfig {
+    mode?: number
     url?: string
-    mode?: string
-    searchParams?: Search
-    threshold?: number
-    serviceTimeout?: number
-    proxy?: string
-    proxyPassword?: string
-    proxyType?: number
+    processParam?: ProcessParams
+    imageFormat?: number
+    imageCompressionQuality?: number
 
-    static fromJson(jsonObject?: any): FaceApiParams | undefined {
+    static fromJson(jsonObject?: any): OnlineProcessingConfig | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new FaceApiParams
+        const result = new OnlineProcessingConfig
 
-        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"]
+        result.url = jsonObject["url"]
+        result.processParam = ProcessParams.fromJson(jsonObject["processParam"])
+        result.imageFormat = jsonObject["imageFormat"]
+        result.imageCompressionQuality = jsonObject["imageCompressionQuality"]
 
         return result
     }
 }
 
-export class Search {
-    limit?: number
-    threshold?: number
-    groupIds?: number[]
+export class DocReaderConfig {
+    license?: string
+    customDb?: string
+    databasePath?: string
+    licenseUpdate?: boolean
+    delayedNNLoad?: boolean
+    blackList?: Record<string, string>
 
-    static fromJson(jsonObject?: any): Search | undefined {
+    static fromJson(jsonObject?: any): DocReaderConfig | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new Search
+        const result = new DocReaderConfig
 
-        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])
+        result.license = jsonObject["license"]
+        result.customDb = jsonObject["customDb"]
+        result.databasePath = jsonObject["databasePath"]
+        result.licenseUpdate = jsonObject["licenseUpdate"]
+        result.delayedNNLoad = jsonObject["delayedNNLoad"]
+        result.blackList = jsonObject["blackList"]
+
+        return result
+    }
+}
+
+export class ScannerConfig {
+    scenario?: string
+    livePortrait?: string
+    extPortrait?: string
+    onlineProcessingConfig?: OnlineProcessingConfig
+    cameraId?: number
+
+    static fromJson(jsonObject?: any): ScannerConfig | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new ScannerConfig
+
+        result.scenario = jsonObject["scenario"]
+        result.livePortrait = jsonObject["livePortrait"]
+        result.extPortrait = jsonObject["extPortrait"]
+        result.onlineProcessingConfig = OnlineProcessingConfig.fromJson(jsonObject["onlineProcessingConfig"])
+        result.cameraId = jsonObject["cameraId"]
+
+        return result
+    }
+}
+
+export class RecognizeConfig {
+    scenario?: string
+    onlineProcessingConfig?: OnlineProcessingConfig
+    oneShotIdentification?: boolean
+    livePortrait?: string
+    extPortrait?: string
+    image?: string
+    data?: string
+    images?: string[]
+    imageInputData?: ImageInputData[]
+
+    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
     }
@@ -1541,11 +1898,12 @@ export class ImageQA {
     angleThreshold?: number
     focusCheck?: boolean
     glaresCheck?: boolean
+    glaresCheckParams?: GlaresCheckParams
     colornessCheck?: boolean
-    moireCheck?: boolean
+    screenCapture?: boolean
     expectedPass?: number[]
-    glaresCheckParams?: GlaresCheckParams
     documentPositionIndent?: number
+    brightnessThreshold?: number
 
     static fromJson(jsonObject?: any): ImageQA | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
@@ -1555,31 +1913,17 @@ export class ImageQA {
         result.angleThreshold = jsonObject["angleThreshold"]
         result.focusCheck = jsonObject["focusCheck"]
         result.glaresCheck = jsonObject["glaresCheck"]
+        result.glaresCheckParams = GlaresCheckParams.fromJson(jsonObject["glaresCheckParams"])
         result.colornessCheck = jsonObject["colornessCheck"]
-        result.moireCheck = jsonObject["moireCheck"]
+        result.screenCapture = jsonObject["screenCapture"]
         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.documentPositionIndent = jsonObject["documentPositionIndent"]
-
-        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"]
+        result.brightnessThreshold = jsonObject["brightnessThreshold"]
 
         return result
     }
@@ -1603,244 +1947,805 @@ export class RFIDParams {
     }
 }
 
-export class OnlineProcessingConfig {
-    mode?: number
+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
-    processParam?: any
-    imageFormat?: number
-    imageCompressionQuality?: number
+    mode?: string
+    threshold?: number
+    searchParams?: FaceApiSearchParams
+    serviceTimeout?: number
+    proxy?: string
+    proxyPassword?: string
+    proxyType?: number
 
-    static fromJson(jsonObject?: any): OnlineProcessingConfig | undefined {
+    static fromJson(jsonObject?: any): FaceApiParams | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new OnlineProcessingConfig
+        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.processParam = jsonObject["processParam"]
-        result.imageFormat = jsonObject["imageFormat"]
-        result.imageCompressionQuality = jsonObject["imageCompressionQuality"]
+        result.httpHeaders = jsonObject["httpHeaders"]
+        result.rfidServerSideChipVerification = jsonObject["rfidServerSideChipVerification"]
 
         return result
     }
 }
 
-export class ScannerConfig {
+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
-    livePortrait?: string
-    extPortrait?: string
-    onlineProcessingConfig?: OnlineProcessingConfig
-    cameraId?: number
+    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.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.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 Font {
+    name?: string
+    size?: number
+    style?: number
 
-    static fromJson(jsonObject?: any): ScannerConfig | undefined {
+    static fromJson(jsonObject?: any): Font | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new ScannerConfig
+        const result = new Font
 
-        result.scenario = jsonObject["scenario"]
-        result.livePortrait = jsonObject["livePortrait"]
-        result.extPortrait = jsonObject["extPortrait"]
-        result.onlineProcessingConfig = OnlineProcessingConfig.fromJson(jsonObject["onlineProcessingConfig"])
-        result.cameraId = jsonObject["cameraId"]
+        result.name = jsonObject["name"]
+        result.size = jsonObject["size"]
+        result.style = jsonObject["style"]
 
         return result
     }
 }
 
-export class RecognizeConfig {
-    scenario?: string
-    livePortrait?: string
-    extPortrait?: string
-    onlineProcessingConfig?: OnlineProcessingConfig
-    image?: string
-    oneShotIdentification?: boolean
-    images?: string[]
-    imageInputData?: ImageInputData[]
+export class CustomizationColors {
+    rfidProcessingScreenBackground?: number
+    rfidProcessingScreenHintLabelText?: number
+    rfidProcessingScreenHintLabelBackground?: number
+    rfidProcessingScreenProgressLabelText?: number
+    rfidProcessingScreenProgressBar?: number
+    rfidProcessingScreenProgressBarBackground?: number
+    rfidProcessingScreenResultLabelText?: number
 
-    static fromJson(jsonObject?: any): RecognizeConfig | undefined {
+    static fromJson(jsonObject?: any): CustomizationColors | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new RecognizeConfig
+        const result = new CustomizationColors
 
-        result.scenario = jsonObject["scenario"]
-        result.livePortrait = jsonObject["livePortrait"]
-        result.extPortrait = jsonObject["extPortrait"]
-        result.onlineProcessingConfig = OnlineProcessingConfig.fromJson(jsonObject["onlineProcessingConfig"])
-        result.image = jsonObject["image"]
-        result.oneShotIdentification = jsonObject["oneShotIdentification"]
-        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)
-            }
-        }
+        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 DocumentReaderResults {
-    videoCaptureSessionId?: string
-    chipPage?: number
-    irElapsedTime?: number
-    processingFinishedStatus?: number
-    elapsedTime?: number
-    elapsedTimeRFID?: number
-    morePagesAvailable?: number
-    rfidResult?: number
-    highResolution?: boolean
-    graphicResult?: DocumentReaderGraphicResult
-    textResult?: DocumentReaderTextResult
-    documentPosition?: ElementPosition[]
-    barcodePosition?: ElementPosition[]
-    mrzPosition?: ElementPosition[]
-    imageQuality?: ImageQualityGroup[]
-    rawResult?: string
-    documentReaderNotification?: DocumentReaderNotification
-    rfidSessionData?: RFIDSessionData
-    authenticityResult?: DocumentReaderAuthenticityResult
-    barcodeResult?: DocumentReaderBarcodeResult
-    ppmIn?: number
-    documentType?: DocumentReaderDocumentType[]
-    status?: DocumentReaderResultsStatus
-    vdsncData?: VDSNCData
+export class CustomizationFonts {
+    rfidProcessingScreenHintLabel?: Font
+    rfidProcessingScreenProgressLabel?: Font
+    rfidProcessingScreenResultLabel?: Font
 
-    textFieldValueByType(fieldType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByType", [this.rawResult, fieldType], successCallback, errorCallback)
-    }
+    static fromJson(jsonObject?: any): CustomizationFonts | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new CustomizationFonts
 
-    textFieldValueByTypeLcid(fieldType, lcid, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcid", [this.rawResult, fieldType, lcid], successCallback, errorCallback)
-    }
+        result.rfidProcessingScreenHintLabel = Font.fromJson(jsonObject["rfidProcessingScreenHintLabel"])
+        result.rfidProcessingScreenProgressLabel = Font.fromJson(jsonObject["rfidProcessingScreenProgressLabel"])
+        result.rfidProcessingScreenResultLabel = Font.fromJson(jsonObject["rfidProcessingScreenResultLabel"])
 
-    textFieldValueByTypeSource(fieldType, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
+        return result
     }
+}
 
-    textFieldValueByTypeLcidSource(fieldType, lcid, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcidSource", [this.rawResult, fieldType, lcid, source], successCallback, errorCallback)
-    }
+export class CustomizationImages {
+    rfidProcessingScreenFailureImage?: string
 
-    textFieldValueByTypeSourceOriginal(fieldType, source, original, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeSourceOriginal", [this.rawResult, fieldType, source, original], successCallback, errorCallback)
-    }
+    static fromJson(jsonObject?: any): CustomizationImages | undefined {
+        if (jsonObject == null || jsonObject == undefined) return undefined
+        const result = new CustomizationImages
 
-    textFieldValueByTypeLcidSourceOriginal(fieldType, lcid, source, original, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldValueByTypeLcidSourceOriginal", [this.rawResult, fieldType, lcid, source, original], successCallback, errorCallback)
-    }
+        result.rfidProcessingScreenFailureImage = jsonObject["rfidProcessingScreenFailureImage"]
 
-    textFieldByType(fieldType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldByType", [this.rawResult, fieldType], successCallback, errorCallback)
+        return result
     }
+}
 
-    textFieldByTypeLcid(fieldType, lcid, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "textFieldByTypeLcid", [this.rawResult, fieldType, lcid], 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"])
 
-    graphicFieldByTypeSource(fieldType, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldByTypeSourcePageIndex(fieldType, source, pageIndex, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex], 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"]
 
-    graphicFieldByTypeSourcePageIndexLight(fieldType, source, pageIndex, light, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex, light], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldImageByType(fieldType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByType", [this.rawResult, fieldType], 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"]
 
-    graphicFieldImageByTypeSource(fieldType, source, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSource", [this.rawResult, fieldType, source], successCallback, errorCallback)
+        return result
     }
+}
 
-    graphicFieldImageByTypeSourcePageIndex(fieldType, source, pageIndex, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSourcePageIndex", [this.rawResult, fieldType, source, pageIndex], 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"]
 
-    graphicFieldImageByTypeSourcePageIndexLight(fieldType, source, pageIndex, light, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "graphicFieldImageByTypeSourcePageIndexLight", [this.rawResult, fieldType, source, pageIndex, light], successCallback, errorCallback)
+        return result
     }
+}
 
-    containers(resultType, successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "containers", [this.rawResult, resultType], 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"])
 
-    encryptedContainers(successCallback, errorCallback) {
-        RNRegulaDocumentReader.exec("DocumentReader", "encryptedContainers", [this.rawResult], successCallback, errorCallback)
+        return result
     }
+}
 
-    static fromJson(jsonObject?: any): DocumentReaderResults | undefined {
+export class PrepareProgress {
+    downloadedBytes?: number
+    totalBytes?: number
+    progress?: number
+
+    static fromJson(jsonObject?: any): PrepareProgress | undefined {
         if (jsonObject == null || jsonObject == undefined) return undefined
-        const result = new DocumentReaderResults
+        const result = new PrepareProgress
 
-        result.videoCaptureSessionId = jsonObject["videoCaptureSessionId"]
-        result.chipPage = jsonObject["chipPage"]
-        result.irElapsedTime = jsonObject["irElapsedTime"]
-        result.processingFinishedStatus = jsonObject["processingFinishedStatus"]
-        result.elapsedTime = jsonObject["elapsedTime"]
-        result.elapsedTimeRFID = jsonObject["elapsedTimeRFID"]
-        result.morePagesAvailable = jsonObject["morePagesAvailable"]
-        result.rfidResult = jsonObject["rfidResult"]
-        result.highResolution = jsonObject["highResolution"]
-        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.documentReaderNotification = DocumentReaderNotification.fromJson(jsonObject["documentReaderNotification"])
-        result.rfidSessionData = RFIDSessionData.fromJson(jsonObject["rfidSessionData"])
-        result.authenticityResult = DocumentReaderAuthenticityResult.fromJson(jsonObject["authenticityResult"])
-        result.barcodeResult = DocumentReaderBarcodeResult.fromJson(jsonObject["barcodeResult"])
-        result.ppmIn = jsonObject["ppmIn"]
-        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.downloadedBytes = jsonObject["downloadedBytes"]
+        result.totalBytes = jsonObject["totalBytes"]
+        result.progress = jsonObject["progress"]
 
         return result
     }
@@ -1877,6 +2782,16 @@ export const eRPRM_Authenticity = {
     OCR: 4194304,
 }
 
+export const CustomizationColor = {
+    RFID_PROCESSING_SCREEN_BACKGROUND: "rfidProcessingScreenBackground",
+    RFID_PROCESSING_SCREEN_HINT_LABEL_TEXT: "rfidProcessingScreenHintLabelText",
+    RFID_PROCESSING_SCREEN_HINT_LABEL_BACKGROUND: "rfidProcessingScreenHintLabelBackground",
+    RFID_PROCESSING_SCREEN_PROGRESS_LABEL_TEXT: "rfidProcessingScreenProgressLabelText",
+    RFID_PROCESSING_SCREEN_PROGRESS_BAR: "rfidProcessingScreenProgressBar",
+    RFID_PROCESSING_SCREEN_PROGRESS_BAR_BACKGROUND: "rfidProcessingScreenProgressBarBackground",
+    RFID_PROCESSING_SCREEN_RESULT_LABEL_TEXT: "rfidProcessingScreenResultLabelText",
+}
+
 export const eRFID_ErrorCodes = {
     RFID_ERROR_NO_ERROR: 0x00000001,
     RFID_ERROR_ALREADY_DONE: 0x00000002,
@@ -2189,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,
@@ -2206,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,
@@ -2236,11 +3152,13 @@ export const eProcessGLCommands = {
     ePC_ProcMgr_ProcessImage: 12104,
     ePC_ProcMgr_StartNewDocument: 12105,
     ePC_ProcMgr_StartNewPage: 12106,
+    ePC_ProcMgr_AddDataToPackage: 12121,
+    ePC_ProcMgr_FinalizePackage: 12122,
+    ePC_ProcMgr_CreateBackendTransaction: 12125,
     ePC_ProcMgr_Unload: 12107,
     ePC_ProcMgr_CheckDatabase: 12109,
     ePC_ProcMgr_ComparePortraits: 12111,
     ePC_RFID_SetTCCParams: 12522,
-    ePC_RFID_SetReprocessingParams: 12523,
 }
 
 export const PKDResourceType = {
@@ -2309,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,
@@ -2328,6 +3251,7 @@ export const ScenarioIdentifier = {
     SCENARIO_MRZ_OR_BARCODE: "MrzOrBarcode",
     SCENARIO_MRZ_OR_LOCATE: "MrzOrLocate",
     SCENARIO_MRZ_AND_LOCATE: "MrzAndLocate",
+    SCENARIO_BARCODE_AND_LOCATE: "BarcodeAndLocate",
     SCENARIO_MRZ_OR_OCR: "MrzOrOcr",
     SCENARIO_MRZ_OR_BARCODE_OR_OCR: "MrzOrBarcodeOrOcr",
     SCENARIO_LOCATE_VISUAL_AND_MRZ_OR_OCR: "LocateVisual_And_MrzOrOcr",
@@ -2338,7 +3262,6 @@ export const ScenarioIdentifier = {
     SCENARIO_OCR_FREE: "OcrFree",
     SCENARIO_CREDIT_CARD: "CreditCard",
     SCENARIO_CAPTURE: "Capture",
-    SCENARIO_BARCODE_AND_LOCATE: "BarcodeAndLocate",
 }
 
 export const eRFID_AccessControl_ProcedureType = {
@@ -2391,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,
@@ -2401,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,
@@ -2469,6 +3415,7 @@ export const eCheckDiagnose = {
     INCORRECT_TEXT_COLOR: 26,
     PHOTO_FALSE_LUMINISCENCE: 27,
     TOO_MUCH_SHIFT: 28,
+    CONTACT_CHIP_TYPE_MISMATCH: 29,
     FIBERS_NOT_FOUND: 30,
     TOO_MANY_OBJECTS: 31,
     SPECKS_IN_UV: 33,
@@ -2554,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,
 }
 
@@ -2570,6 +3523,20 @@ export const TextProcessing = {
     ocCapital: 3,
 }
 
+export const AnimationImage = {
+    UNKNOWN: 0,
+    PASSPORT_SINGLE_PAGE: 1,
+    PASSPORT_TWO_PAGES: 2,
+    ID_FRONT: 3,
+    ID_FRONT_MRZ: 4,
+    ID_BACK: 5,
+    ID_BACK_MRZ: 6,
+    ID_BACK_BARCODE: 7,
+    ID_BACK_BARCODE_MRZ: 8,
+    BANK_CARD_FRONT: 9,
+    BANK_CARD_BACK: 10,
+}
+
 export const ProcessingFinishedStatus = {
     NOT_READY: 0,
     READY: 1,
@@ -2814,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 = {
@@ -2826,6 +3797,7 @@ export const eImageQualityCheckType = {
     IQC_SCREEN_CAPTURE: 6,
     IQC_PORTRAIT: 7,
     IQC_HANDWRITTEN: 8,
+    IQC_BRIGHTNESS: 9,
 }
 
 export const MRZFormat = {
@@ -2907,6 +3879,12 @@ export const eRPRM_SecurityFeatureType = {
     SECURITY_FEATURE_TYPE_LAS_INK: 43,
     SECURITY_FEATURE_TYPE_LIVENESS_MLI: 44,
     SECURITY_FEATURE_TYPE_LIVENESS_BARCODE_BACKGROUND: 45,
+    SECURITY_FEATURE_TYPE_PORTRAIT_COMPARISON_VS_BARCODE: 46,
+    SECURITY_FEATURE_TYPE_PORTRAIT_COMPARISON_RFID_VS_BARCODE: 47,
+    SECURITY_FEATURE_TYPE_PORTRAIT_COMPARISON_EXT_VS_BARCODE: 48,
+    SECURITY_FEATURE_TYPE_PORTRAIT_COMPARISON_BARCODE_VS_CAMERA: 49,
+    SECURITY_FEATURE_TYPE_CHECK_DIGITAL_SIGNATURE: 50,
+    SECURITY_FEATURE_TYPE_CONTACT_CHIP_CLASSIFICATION: 51,
 }
 
 export const OnlineMode = {
@@ -3152,6 +4130,15 @@ export const diDocType = {
     dtPassengerLocatorForm: 242,
 }
 
+export const ButtonTag = {
+    CLOSE: 1001,
+    TORCH: 1002,
+    CAPTURE: 1003,
+    CHANGE_FRAME: 1004,
+    SKIP: 1005,
+    CAMERA_SWITCH: 1006,
+}
+
 export const HoloAnimationType = {
     DocumentHoloAnimationUnknown: 0,
     DocumentHoloAnimationTypeHorizontal: 1,
@@ -3170,6 +4157,12 @@ export const eRequestCommand = {
     eReqCmd_WltToImage: 401,
 }
 
+export const CustomizationFont = {
+    RFID_PROCESSING_SCREEN_HINT_LABEL: "rfidProcessingScreenHintLabel",
+    RFID_PROCESSING_SCREEN_PROGRESS_LABEL: "rfidProcessingScreenProgressLabel",
+    RFID_PROCESSING_SCREEN_RESULT_LABEL: "rfidProcessingScreenResultLabel",
+}
+
 export const ImageFormat = {
     PNG: 0,
     JPG: 1,
@@ -3187,6 +4180,7 @@ export const eGraphicFieldType = {
     GF_GHOST_PORTRAIT: 210,
     GF_STAMP: 211,
     GF_PORTRAIT_OF_CHILD: 212,
+    GF_CONTACT_CHIP: 213,
     GF_OTHER: 250,
     GF_FINGER_LEFT_THUMB: 300,
     GF_FINGER_LEFT_INDEX: 301,
@@ -3201,7 +4195,23 @@ export const eGraphicFieldType = {
 }
 
 export const RegDeviceConfigType = {
-    DEVICE_7310: 1,
+    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 = {
@@ -3949,6 +4959,9 @@ export const eVisualFieldType = {
     FT_ADDRESS_COUNTY_TYPE: 678,
     FT_ADDRESS_CITY_TYPE: 679,
     FT_ADDRESS_BUILDING_TYPE: 680,
+    FT_DATE_OF_RETIREMENT: 681,
+    FT_DOCUMENT_STATUS: 682,
+    FT_SIGNATURE: 683,
 }
 
 export const DocReaderOrientation = {
@@ -3992,7 +5005,7 @@ export const LCID = {
     BANK_CARD_NUMBER: 10000,
     BANK_CARD_VALID_THRU: 10001,
     BELARUSIAN: 1059,
-    BENGALI: 2117,
+    BENGALI_BANGLADESH: 2117,
     BULGARIAN: 1026,
     CATALAN: 1027,
     CHINESE_HONGKONG_SAR: 3076,
@@ -4058,6 +5071,7 @@ export const LCID = {
     LITHUANIAN: 1063,
     MALAY_MALAYSIA: 1086,
     MALAY_BRUNEI_DARUSSALAM: 2110,
+    ASSAMESE: 1101,
     MARATHI: 1102,
     MONGOLIAN_CYRILIC: 1104,
     NORWEGIAN_BOKMAL: 1044,
@@ -4104,6 +5118,7 @@ export const LCID = {
     SYRIAC: 1114,
     TAMIL: 1097,
     TATAR: 1092,
+    BENGALI_INDIA: 1093,
     TELUGU: 1098,
     THAI_THAILAND: 1054,
     TURKISH: 1055,
@@ -4116,6 +5131,18 @@ export const LCID = {
     VIETNAMESE: 1066,
     CTC_SIMPLIFIED: 50001,
     CTC_TRADITIONAL: 50002,
+    MALTESE: 1082,
+    BURMESE: 1109,
+    KHMER: 1107,
+    KARAKALPAK_LATIN: 10012,
+    MALAYALAM: 1100,
+    NEPALI: 1121,
+    ORIYA: 1096,
+    URDU_DETECTION: 10560,
+}
+
+export const CustomizationImage = {
+    RFID_PROCESSING_SCREEN_FAILURE_IMAGE: "rfidProcessingScreenFailureImage",
 }
 
 export const DocReaderFrame = {
@@ -4137,72 +5164,18 @@ 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,
+   CustomizationColor,
    eRFID_ErrorCodes,
    eLDS_ParsingErrorCodes,
    eRFID_CertificateType,
    RGLMeasureSystem,
    eRPRM_ResultType,
-   CameraTypes,
    FrameShapeType,
    eRFID_BaudRate,
+   LineCap,
    eRPRM_FieldVerificationResult,
    DocReaderAction,
    eProcessGLCommands,
@@ -4212,12 +5185,15 @@ export const Enum = {
    ScenarioIdentifier,
    eRFID_AccessControl_ProcedureType,
    eRFID_NotificationCodes,
+   CameraPosition,
    eRFID_Password_Type,
+   ViewContentMode,
    BarcodeResult,
    eSignManagementAction,
    eCheckDiagnose,
    RFIDDelegate,
    TextProcessing,
+   AnimationImage,
    ProcessingFinishedStatus,
    DocFormat,
    eLDS_ParsingNotificationCodes,
@@ -4228,11 +5204,14 @@ export const Enum = {
    OnlineMode,
    eRFID_SDK_ProfilerType,
    diDocType,
+   ButtonTag,
    HoloAnimationType,
    eRequestCommand,
+   CustomizationFont,
    ImageFormat,
    eGraphicFieldType,
    RegDeviceConfigType,
+   CaptureSessionPreset,
    CameraMode,
    CaptureMode,
    eCheckResult,
@@ -4241,108 +5220,58 @@ export const Enum = {
    eVisualFieldType,
    DocReaderOrientation,
    LCID,
+   CustomizationImage,
    DocReaderFrame,
    eRPRM_Lights,
-   LineCap,
-   UIInterfaceOrientationMask,
-   AVCaptureSessionPreset,
-   AVCaptureDevicePosition,
-   UIViewContentMode,
 }
 
 export default class DocumentReader {
-    static initializeReaderAutomatically(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static isBlePermissionsGranted(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static startBluetoothService(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static initializeReaderBleDeviceConfig(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getTag(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getAPIVersion(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getAvailableScenarios(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static isRFIDAvailableForUse(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getCoreMode(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getCoreVersion(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getDatabaseDate(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getDatabaseID(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getDatabaseVersion(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getDocumentReaderIsReady(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static getDocumentReaderStatus(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getDatabaseCountriesNumber(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getDatabaseDocumentsNumber(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static selectedScenario(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getSessionLogFolder(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getDatabaseDescription(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static showScanner(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static startNewPage(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static startNewSession(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static startRFIDReader(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static stopRFIDReader(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static stopRFIDReaderWithErrorMessage(message: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static stopScanner(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static deinitializeReader(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
     static isAuthenticatorAvailableForUse(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getConfig(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static isBlePermissionsGranted(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    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 | null, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static getFunctionality(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: ProcessParams, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
+    static getCustomization(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 getLicenseExpiryDate(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getLicenseCountryFilter(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static licenseIsRfidAvailable(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getCameraSessionIsPaused(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 resetConfiguration(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static clearPKDCertificates(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static readRFID(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static getRfidSessionStatus(successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setRfidDelegate(delegate: number, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setEnableCoreLogs(logs: boolean, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static addPKDCertificates(certificates: PKDCertificate[], successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setCameraSessionIsPaused(paused: boolean, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setTag(tag: string, 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
-    /**
-     * @deprecated
-     */
-    static recognizeImages(images: string[], successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static showScannerWithCameraID(cameraID: number, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static runAutoUpdate(databaseType: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setConfig(config: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setRfidScenario(scenario: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static initializeReader(config: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static prepareDatabase(databaseType: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static recognizeImage(image: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static recognizeData(data: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setRfidSessionStatus(status: string, 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 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 readRFID(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 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 parseCoreResults(json: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setTCCParams(params: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static recognizeImageWithOpts(image: string, options: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static recognizeVideoFrame(byteString: string, params: string, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static showScannerWithCameraIDAndOpts(cameraID: number, options: any, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static recognizeImageWithCameraMode(image: string, mode: boolean, successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    /**
-     * @deprecated
-     */
-    static recognizeImagesWithImageInputs(images: ImageInputData[], successCallback: (response: string) => void, errorCallback?: (error: string) => void): void
-    static setLanguage(language: string, 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: 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 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
 }