@microblink/blinkid-react-native 7.6.2 → 8000.0.0

package/ios/Serialization/BlinkIdSerializationUtils.swift

@@ -0,0 +1,866 @@
+//
+//  BlinkIdDeserializationUtilities.swift
+//  BlinkidReactNative
+//
+//  Created by Milan Parađina on 22.05.2025..
+//
+
+import Foundation
+import BlinkID
+import UIKit
+
+class BlinkIdSerializationUtils {
+
+    static func serializeBlinkIdScanningResult(_ scanningResult: BlinkIDScanningResult?) -> String? {
+        var scanningResultDict = Dictionary<String, Any>()
+        
+        if let scanningResult {
+            
+            scanningResultDict["documentClassInfo"] = serializeDocumentClassInfo(scanningResult.documentClassInfo)
+
+            if let dataMatchResult = scanningResult.dataMatchResult {
+                scanningResultDict["dataMatchResult"] = serializeDataMatchResult(dataMatchResult)
+            }
+            if let firstName = scanningResult.firstName {
+                scanningResultDict["firstName"] = serializeStringResult(firstName)
+            }
+            if let lastName = scanningResult.lastName {
+                scanningResultDict["lastName"] = serializeStringResult(lastName)
+            }
+            if let fullName = scanningResult.fullName {
+                scanningResultDict["fullName"] = serializeStringResult(fullName)
+            }
+            if let additionalNameInformation = scanningResult.additionalNameInformation {
+                scanningResultDict["additionalNameInformation"] = serializeStringResult(additionalNameInformation)
+            }
+            if let localizedName = scanningResult.localizedName {
+                scanningResultDict["localizedName"] = serializeStringResult(localizedName)
+            }
+            if let fathersName = scanningResult.fathersName {
+                scanningResultDict["fathersName"] = serializeStringResult(fathersName)
+            }
+            if let mothersName = scanningResult.mothersName {
+                scanningResultDict["mothersName"] = serializeStringResult(mothersName)
+            }
+            if let address = scanningResult.address {
+                scanningResultDict["address"] = serializeStringResult(address)
+            }
+            if let additionalAddressInformation = scanningResult.additionalAddressInformation {
+                scanningResultDict["additionalAddressInformation"] = serializeStringResult(additionalAddressInformation)
+            }
+            if let additionalOptionalAddressInformation = scanningResult.additionalOptionalAddressInformation {
+                scanningResultDict["additionalOptionalAddressInformation"] = serializeStringResult(additionalOptionalAddressInformation)
+            }
+            if let placeOfBirth = scanningResult.placeOfBirth {
+                scanningResultDict["placeOfBirth"] = serializeStringResult(placeOfBirth)
+            }
+            if let nationality = scanningResult.nationality {
+                scanningResultDict["nationality"] = serializeStringResult(nationality)
+            }
+            if let race = scanningResult.race {
+                scanningResultDict["race"] = serializeStringResult(race)
+            }
+            if let religion = scanningResult.religion {
+                scanningResultDict["religion"] = serializeStringResult(religion)
+            }
+            if let profession = scanningResult.profession {
+                scanningResultDict["profession"] = serializeStringResult(profession)
+            }
+            if let maritalStatus = scanningResult.maritalStatus {
+                scanningResultDict["maritalStatus"] = serializeStringResult(maritalStatus)
+            }
+            if let residentialStatus = scanningResult.residentialStatus {
+                scanningResultDict["residentialStatus"] = serializeStringResult(residentialStatus)
+            }
+            if let employer = scanningResult.employer {
+                scanningResultDict["employer"] = serializeStringResult(employer)
+            }
+            if let sex = scanningResult.sex {
+                scanningResultDict["sex"] = serializeStringResult(sex)
+            }
+            if let sponsor = scanningResult.sponsor {
+                scanningResultDict["sponsor"] = serializeStringResult(sponsor)
+            }
+            if let bloodType = scanningResult.bloodType {
+                scanningResultDict["bloodType"] = serializeStringResult(bloodType)
+            }
+            if let documentNumber = scanningResult.documentNumber {
+                scanningResultDict["documentNumber"] = serializeStringResult(documentNumber)
+            }
+            if let cardAccessNumber = scanningResult.cardAccessNumber {
+                scanningResultDict["cardAccessNumber"] = serializeStringResult(cardAccessNumber)
+            }
+            if let personalIdNumber = scanningResult.personalIdNumber {
+                scanningResultDict["personalIdNumber"] = serializeStringResult(personalIdNumber)
+            }
+            if let documentAdditionalNumber = scanningResult.documentAdditionalNumber {
+                scanningResultDict["documentAdditionalNumber"] = serializeStringResult(documentAdditionalNumber)
+            }
+            if let documentOptionalAdditionalNumber = scanningResult.documentOptionalAdditionalNumber {
+                scanningResultDict["documentOptionalAdditionalNumber"] = serializeStringResult(documentOptionalAdditionalNumber)
+            }
+            if let additionalPersonalIdNumber = scanningResult.additionalPersonalIdNumber {
+                scanningResultDict["additionalPersonalIdNumber"] = serializeStringResult(additionalPersonalIdNumber)
+            }
+            if let issuingAuthority = scanningResult.issuingAuthority {
+                scanningResultDict["issuingAuthority"] = serializeStringResult(issuingAuthority)
+            }
+            if let documentSubtype = scanningResult.documentSubtype {
+                scanningResultDict["documentSubtype"] = serializeStringResult(documentSubtype)
+            }
+            if let remarks = scanningResult.remarks {
+                scanningResultDict["remarks"] = serializeStringResult(remarks)
+            }
+            if let residencePermitType = scanningResult.residencePermitType {
+                scanningResultDict["residencePermitType"] = serializeStringResult(residencePermitType)
+            }
+            if let manufacturingYear = scanningResult.manufacturingYear {
+                scanningResultDict["manufacturingYear"] = serializeStringResult(manufacturingYear)
+            }
+            if let vehicleType = scanningResult.vehicleType {
+                scanningResultDict["vehicleType"] = serializeStringResult(vehicleType)
+            }
+            if let eligibilityCategory = scanningResult.eligibilityCategory {
+                scanningResultDict["eligibilityCategory"] = serializeStringResult(eligibilityCategory)
+            }
+            if let specificDocumentValidity = scanningResult.specificDocumentValidity {
+                scanningResultDict["specificDocumentValidity"] = serializeStringResult(specificDocumentValidity)
+            }
+            if let visaType = scanningResult.visaType {
+                scanningResultDict["visaType"] = serializeStringResult(visaType)
+            }
+            if let vehicleOwner = scanningResult.vehicleOwner {
+                scanningResultDict["vehicleOwner"] = serializeStringResult(vehicleOwner)
+            }
+            if let certificateNumber = scanningResult.certificateNumber {
+                scanningResultDict["certificateNumber"] = serializeStringResult(certificateNumber)
+            }
+            if let countryCode = scanningResult.countryCode {
+                scanningResultDict["countryCode"] = serializeStringResult(countryCode)
+            }
+            if let nationalInsuranceNumber = scanningResult.nationalInsuranceNumber {
+                scanningResultDict["nationalInsuranceNumber"] = serializeStringResult(nationalInsuranceNumber)
+            }
+            if let localityCode = scanningResult.localityCode {
+                scanningResultDict["localityCode"] = serializeStringResult(localityCode)
+            }
+            if let maidenName = scanningResult.maidenName {
+                scanningResultDict["maidenName"] = serializeStringResult(maidenName)
+            }
+            if let municipalityCode = scanningResult.municipalityCode {
+                scanningResultDict["municipalityCode"] = serializeStringResult(municipalityCode)
+            }
+            if let municipalityOfRegistration = scanningResult.municipalityOfRegistration {
+                scanningResultDict["municipalityOfRegistration"] = serializeStringResult(municipalityOfRegistration)
+            }
+            if let pollingStationCode = scanningResult.pollingStationCode {
+                scanningResultDict["pollingStationCode"] = serializeStringResult(pollingStationCode)
+            }
+            if let registrationCenterCode = scanningResult.registrationCenterCode {
+                scanningResultDict["registrationCenterCode"] = serializeStringResult(registrationCenterCode)
+            }
+            if let sectionCode = scanningResult.sectionCode {
+                scanningResultDict["sectionCode"] = serializeStringResult(sectionCode)
+            }
+            if let stateCode = scanningResult.stateCode {
+                scanningResultDict["stateCode"] = serializeStringResult(stateCode)
+            }
+            if let stateName = scanningResult.stateName {
+                scanningResultDict["stateName"] = serializeStringResult(stateName)
+            }
+            if let dateOfBirth = scanningResult.dateOfBirth {
+                scanningResultDict["dateOfBirth"] = serializeDateResult(dateOfBirth)
+            }
+            if let dateOfIssue = scanningResult.dateOfIssue {
+                scanningResultDict["dateOfIssue"] = serializeDateResult(dateOfIssue)
+            }
+            if let dateOfExpiry = scanningResult.dateOfExpiry {
+                scanningResultDict["dateOfExpiry"] = serializeDateResult(dateOfExpiry)
+            }
+            if let dateOfEntry = scanningResult.dateOfEntry {
+                scanningResultDict["dateOfEntry"] = serializeDateResult(dateOfEntry)
+            }
+            if let effectiveDate = scanningResult.effectiveDate {
+                scanningResultDict["effectiveDate"] = serializeDateResult(effectiveDate)
+            }
+            if let dateOfExpiryPermanent = scanningResult.dateOfExpiryPermanent {
+                scanningResultDict["dateOfExpiryPermanent"] = dateOfExpiryPermanent
+            }
+            if let driverLicenseDetailedInfo = scanningResult.driverLicenseDetailedInfo {
+                scanningResultDict["driverLicenseDetailedInfo"] = serializeDriverLicenseDetailedInfo(driverLicenseDetailedInfo)
+            }
+            if let dependentsInfo = scanningResult.dependentsInfo {
+                scanningResultDict["dependentsInfo"] = dependentsInfo.map(serializeDependentInfo(_:))
+            }
+            if let parentsInfo = scanningResult.parentsInfo {
+                scanningResultDict["parentsInfo"] = parentsInfo.map(serializeParentInfo(_:))
+            }
+            if let husbandName = scanningResult.husbandName {
+                scanningResultDict["husbandName"] = serializeStringResult(husbandName)
+            }
+            if let legalStatus = scanningResult.legalStatus {
+                scanningResultDict["legalStatus"] = serializeStringResult(legalStatus)
+            }
+            if let socialSecurityStatus = scanningResult.socialSecurityStatus {
+                scanningResultDict["socialSecurityStatus"] = serializeStringResult(socialSecurityStatus)
+            }
+            if let workRestriction = scanningResult.workRestriction {
+                scanningResultDict["workRestriction"] = serializeStringResult(workRestriction)
+            }
+            scanningResultDict["subResults"] = scanningResult.subResults.map(serializeSingleSideScanningResult(_:))
+
+            if let firstInputImage = scanningResult.getInputImage(scanningSide: .first) {
+                scanningResultDict["firstInputImage"] = encodeImage(firstInputImage.uiImage)
+            }
+            if let secondInputImage = scanningResult.getInputImage(scanningSide: .second) {
+                scanningResultDict["secondInputImage"] = encodeImage(secondInputImage.uiImage)
+            }
+            if let barcodeImage = scanningResult.getBarcodeImage() {
+                scanningResultDict["barcodeImage"] = encodeImage(barcodeImage.uiImage)
+            }
+            if let firstDocumentImage = scanningResult.getDocumentImage(scanningSide: .first) {
+                scanningResultDict["firstDocumentImage"] = encodeImage(firstDocumentImage.uiImage)
+            }
+            if let secondDocumentImage = scanningResult.getDocumentImage(scanningSide: .second) {
+                scanningResultDict["secondDocumentImage"] = encodeImage(secondDocumentImage.uiImage)
+            }
+            if let faceImage = scanningResult.getFaceImage() {
+                scanningResultDict["faceImage"] = serializeDetailedCroppedImageResult(faceImage)
+            }
+            if let signatureImage = scanningResult.getSignatureImage() {
+                scanningResultDict["signatureImage"] = serializeDetailedCroppedImageResult(signatureImage)
+            }
+        }
+        
+        return encodeToJson(scanningResultDict)
+    }
+    
+    static func serializeDocumentClassInfo(_ documentClassInfo: BlinkIDSDK.DocumentClassInfo) -> Dictionary<String, Any?> {
+        // TODO: Align country/region/documentType strings with Android (enum.name lowercased).
+        // iOS uses rawValue here; values usually match TS types but are not guaranteed identical
+        // for every enum. Prefer shared explicit string mappers on both platforms.
+        [
+            "country": documentClassInfo.country.rawValue,
+            "region": documentClassInfo.region.rawValue,
+            "documentType": documentClassInfo.documentType.rawValue,
+            "countryName": documentClassInfo.countryName,
+            "isoNumericCountryCode": documentClassInfo.isoNumericCountryCode,
+            "isoAlpha2CountryCode": documentClassInfo.isoAlpha2CountryCode,
+            "isoAlpha3CountryCode": documentClassInfo.isoAlpha3CountryCode,
+            "empty": documentClassInfo.isEmpty()
+        ]
+    }
+    
+    static func serializeDataMatchResult(_ dataMatchResult: DataMatchResult?) -> Dictionary<String, Any?> {
+        return [
+            "states": dataMatchResult?.states.map(serializeDataMatchState(_:)),
+            "overallState": deserializeDataMatchState(dataMatchResult?.overallState)
+        ]
+    }
+    
+    static func serializeDataMatchState(_ dataMatchState: FieldState) -> Dictionary<String, Any> {
+        return [
+            "field": deserializeDataMatchField(dataMatchState.fieldType),
+            "state": deserializeDataMatchState(dataMatchState.state)
+        ]
+    }
+    
+    static func deserializeDataMatchField(_ field: DataMatchFieldType) -> String {
+        switch field {
+        case .dateOfBirth:
+            return "dateOfBirth"
+        case .dateOfExpiry:
+            return "dateOfExpiry"
+        case .documentNumber:
+            return "documentNumber"
+        case .documentAdditionalNumber:
+            return "documentAdditionalNumber"
+        case .documentOptionalAdditionalNumber:
+            return "documentOptionalAdditionalNumber"
+        case .personalIdNumber:
+            return "personalIdNumber"
+        @unknown default:
+            return ""
+        }
+    }
+
+    static func serializeStringResult(_ stringResult: BlinkIDSDK.StringResult?) -> Dictionary<String, Any?>{
+        var stringResultDict: Dictionary<String, Any?> = [
+            "value": stringResult?.value,
+            "latin": stringResult?.value(for: .latin),
+            "arabic": stringResult?.value(for: .arabic),
+            "cyrillic": stringResult?.value(for: .cyrillic),
+            "greek": stringResult?.value(for: .greek)
+        ]
+                
+        stringResultDict["location"] = [
+            "latin": serializeRect(stringResult?.location(for: .latin)),
+            "arabic": serializeRect(stringResult?.location(for: .arabic)),
+            "cyrillic": serializeRect(stringResult?.location(for: .cyrillic)),
+            "greek": serializeRect(stringResult?.location(for: .greek))
+        ]
+        
+        var sideDict: Dictionary<String, Any?> = [
+            "latin": serializeScanningSide(stringResult?.side(for: .latin)),
+            "arabic": serializeScanningSide(stringResult?.side(for: .arabic)),
+            "cyrillic": serializeScanningSide(stringResult?.side(for: .cyrillic)),
+            "greek": serializeScanningSide(stringResult?.side(for: .greek))
+        ]
+        stringResultDict["side"] = sideDict
+        
+        return stringResultDict
+    }
+    
+    static func serializeRect(_ rectangle:  BlinkID.RectangleF?) -> Dictionary<String, Any> {
+        let rectangleDict: [String: Any?] = [
+          "x": rectangle?.origin.x,
+          "y": rectangle?.origin.y,
+          "width": rectangle?.width,
+          "height": rectangle?.height
+        ]
+        return rectangleDict.compactMapValues { $0 }
+    }
+    
+    static func serializeDateResult<T>(_ dateResult: DateResult<T>?) -> Dictionary<String, Any?>? {
+        return [
+            "date": serializeSimpleDate(dateResult),
+            "filledByDomainKnowledge": dateResult?.filledByDomainKnowledge,
+            "successfullyParsed": dateResult?.successfullyParsed,
+            "originalString": serializeStringType(dateResult?.originalString)
+        ]
+    }
+    
+    static func serializeSimpleDate<T>(_ dateResult: DateResult<T>?) -> Dictionary<String, Any>? {
+        let simpleDateDict: [String: Any?] = [
+        "day": dateResult?.day,
+        "month": dateResult?.month,
+        "year": dateResult?.year,
+      ]
+        return simpleDateDict.compactMapValues { $0 }
+    }
+    
+    static func serializeDriverLicenseDetailedInfo<T>(_ driverLicenseDetailedInfo:  DriverLicenseDetailedInfo<T>?) -> Dictionary<String, Any?>? {
+        return [
+            "conditions": serializeStringType(driverLicenseDetailedInfo?.conditions),
+            "endorsements": serializeStringType(driverLicenseDetailedInfo?.endorsements),
+            "restrictions": serializeStringType(driverLicenseDetailedInfo?.restrictions),
+            "vehicleClass": serializeStringType(driverLicenseDetailedInfo?.vehicleClass),
+            "vehicleClassesInfo": driverLicenseDetailedInfo?.vehicleClassesInfo?.map(serializeVehicleClassInfo(_:)),
+        ]
+    }
+    
+    static func serializeVehicleClassInfo<T>(_ vehicleClassInfo: VehicleClassInfo<T>?) -> Dictionary<String, Any?> {
+        return [
+            "effectiveDate": serializeDateResult(vehicleClassInfo?.effectiveDate),
+            "expiryDate":  serializeDateResult(vehicleClassInfo?.expiryDate),
+            "licenceType": serializeStringType(vehicleClassInfo?.licenceType),
+            "vehicleClass": serializeStringType(vehicleClassInfo?.vehicleClass)
+        ]
+    }
+    static func serializeDependentInfo(_ dependentInfo: DependentInfo?) -> Dictionary<String, Any?> {
+        return [
+            "dateOfBirth": serializeDateResult(dependentInfo?.dateOfBirth),
+            "documentNumber": serializeStringResult(dependentInfo?.documentNumber),
+            "fullName": serializeStringResult(dependentInfo?.fullName),
+            "sex": serializeStringResult(dependentInfo?.sex)
+        ]
+    }
+    
+    static func serializeSingleSideScanningResult(_ singleSideScanningResult: SingleSideScanningResult?) -> Dictionary<String, Any?> {
+        guard let singleSideScanningResult else { return [:] }
+        
+        return [
+            "viz": serializeVizResult(singleSideScanningResult.viz),
+            "mrz": serializeMrzResult(singleSideScanningResult.mrz),
+            "barcode": serializeBarcodeResult(singleSideScanningResult.barcode),
+            "inputImage": encodeImage(singleSideScanningResult.inputImage?.uiImage),
+            "barcodeImage": encodeImage(singleSideScanningResult.barcodeImage?.uiImage),
+            "documentImage": encodeImage(singleSideScanningResult.documentImage?.uiImage),
+            "faceImage": serializeDetailedCroppedImageResult(singleSideScanningResult.faceImage),
+            "signatureImage": serializeDetailedCroppedImageResult(singleSideScanningResult.signatureImage),
+                
+            ]
+    }
+    
+    static func serializeBarcodeResult(_ barcodeResult: BarcodeResult?) -> Dictionary<String, Any?> {
+        return [
+            "barcodeData": serializeBarcodeData(barcodeResult?.barcodeData),
+            "parsed": barcodeResult?.parsed,
+            "firstName": barcodeResult?.firstName,
+            "middleName": barcodeResult?.middleName,
+            "lastName": barcodeResult?.lastName,
+            "fullName": barcodeResult?.fullName,
+            "additionalNameInformation": barcodeResult?.additionalNameInformation,
+            "address": barcodeResult?.address,
+            "nationality": barcodeResult?.nationality,
+            "placeOfBirth": barcodeResult?.placeOfBirth,
+            "race": barcodeResult?.race,
+            "religion": barcodeResult?.religion,
+            "profession": barcodeResult?.profession,
+            "maritalStatus": barcodeResult?.maritalStatus,
+            "residentialStatus": barcodeResult?.residentialStatus,
+            "employer": barcodeResult?.employer,
+            "sex": barcodeResult?.sex,
+            "dateOfBirth": serializeDateResult(barcodeResult?.dateOfBirth),
+            "dateOfIssue": serializeDateResult(barcodeResult?.dateOfIssue),
+            "dateOfExpiry": serializeDateResult(barcodeResult?.dateOfExpiry),
+            "documentNumber": barcodeResult?.documentNumber,
+            "personalIdNumber": barcodeResult?.personalIdNumber,
+            "documentAdditionalNumber": barcodeResult?.documentAdditionalNumber,
+            "issuingAuthority": barcodeResult?.issuingAuthority,
+            "addressDetailedInfo": serializeAddressDetailedInfo(barcodeResult?.addressDetailedInfo),
+            "driverLicenseDetailedInfo": serializeDriverLicenseDetailedInfo(barcodeResult?.driverLicenseDetailedInfo),
+            "extendedElements": serializeBarcodeExtendedElements(barcodeResult?.extendedElements),
+        ]
+    }
+    
+    static func serializeAddressDetailedInfo(_ addressDetailedInfo: AddressDetailedInfo?) -> Dictionary<String, Any?> {
+        return [
+            "city": addressDetailedInfo?.city,
+            "postalCode": addressDetailedInfo?.postalCode,
+            "jurisdiction": addressDetailedInfo?.jurisdiction,
+            "street": addressDetailedInfo?.street
+        ]
+    }
+    static func serializeBarcodeData(_ barcodeData: BarcodeData?) -> Dictionary<String, Any?> {
+        return [
+            "barcodeType": serializeBarcodeType(barcodeData?.barcodeType),
+            "rawData": barcodeData?.rawData.base64EncodedString(),
+            "stringData": barcodeData?.stringData,
+            "uncertain": barcodeData?.uncertain
+        ]
+    }
+    
+    static func serializeBarcodeType(_ barcodeType: BarcodeType?) -> String {
+        switch barcodeType {
+        case nil:
+            return "none"
+        case .qrCode:
+            return "qrCode"
+        case .dataMatrix:
+            return "dataMatrix"
+        case .upce:
+            return "upce"
+        case .upca:
+            return "upca"
+        case .ean8:
+            return "ean8"
+        case .ean13:
+            return "ean13"
+        case .code128:
+            return "code128"
+        case .code39:
+            return "code39"
+        case .itf:
+            return "itf"
+        case .aztec:
+            return "aztec"
+        case .pdf417:
+            return "pdf417"
+        case .none?:
+            return "none"
+        @unknown default:
+            return "none"
+        }
+    }
+
+    static func serializeBarcodeExtendedElements(_ barcodeExtendedElements: BarcodeElements?) -> [String: Any?] {
+        var elements = barcodeExtendedElements
+        
+        return [
+            "addressCity": elements?.getValue(for: .addressCity),
+            "addressJurisdictionCode": elements?.getValue(for: .addressJurisdictionCode),
+            "addressPostalCode": elements?.getValue(for: .addressPostalCode),
+            "addressStreet": elements?.getValue(for: .addressStreet),
+            "addressStreet2": elements?.getValue(for: .addressStreet2),
+            "akaDateOfBirth": elements?.getValue(for: .akaDateOfBirth),
+            "akaFamilyName": elements?.getValue(for: .akaFamilyName),
+            "akaFullName": elements?.getValue(for: .akaFullName),
+            "akaGivenName": elements?.getValue(for: .akaGivenName),
+            "akaMiddleName": elements?.getValue(for: .akaMiddleName),
+            "akaPrefixName": elements?.getValue(for: .akaPrefixName),
+            "akaSocialSecurityNumber": elements?.getValue(for: .akaSocialSecurityNumber),
+            "akaSuffixName": elements?.getValue(for: .akaSuffixName),
+            "auditInformation": elements?.getValue(for: .auditInformation),
+            "cardRevisionDate": elements?.getValue(for: .cardRevisionDate),
+            "complianceType": elements?.getValue(for: .complianceType),
+            "countryIdentification": elements?.getValue(for: .countryIdentification),
+            "customerFamilyName": elements?.getValue(for: .customerFamilyName),
+            "customerIdNumber": elements?.getValue(for: .customerIdNumber),
+            "customerFirstName": elements?.getValue(for: .customerFirstName),
+            "customerFullName": elements?.getValue(for: .customerFullName),
+            "customerMiddleName": elements?.getValue(for: .customerMiddleName),
+            "dataDiscriminator": elements?.getValue(for: .dataDiscriminator),
+            "dateOfBirth": elements?.getValue(for: .dateOfBirth),
+            "documentDiscriminator": elements?.getValue(for: .documentDiscriminator),
+            "documentExpirationDate": elements?.getValue(for: .documentExpirationDate),
+            "documentExpirationMonth": elements?.getValue(for: .documentExpirationMonth),
+            "documentIssueDate": elements?.getValue(for: .documentIssueDate),
+            "documentNonexpiring": elements?.getValue(for: .documentNonexpiring),
+            "documentType": elements?.getValue(for: .documentType),
+            "eyeColor": elements?.getValue(for: .eyeColor),
+            "familyNameTruncation": elements?.getValue(for: .familyNameTruncation),
+            "federalCommercialVehicleCodes": elements?.getValue(for: .federalCommercialVehicleCodes),
+            "firstNameTruncation": elements?.getValue(for: .firstNameTruncation),
+            "fullAddress": elements?.getValue(for: .fullAddress),
+            "hairColor": elements?.getValue(for: .hairColor),
+            "height": elements?.getValue(for: .height),
+            "heightIn": elements?.getValue(for: .heightIn),
+            "heightCm": elements?.getValue(for: .heightCm),
+            "issuerIdentificationNumber": elements?.getValue(for: .issuerIdentificationNumber),
+            "issuingJurisdiction": elements?.getValue(for: .issuingJurisdiction),
+            "issuingJurisdictionName": elements?.getValue(for: .issuingJurisdictionName),
+            "jurisdictionEndorsementCodes": elements?.getValue(for: .jurisdictionEndorsementCodes),
+            "jurisdictionEndorsmentCodeDescription": elements?.getValue(for: .jurisdictionEndorsmentCodeDescription),
+            "jurisdictionRestrictionCodeDescription": elements?.getValue(for: .jurisdictionRestrictionCodeDescription),
+            "jurisdictionRestrictionCodes": elements?.getValue(for: .jurisdictionRestrictionCodes),
+            "jurisdictionVehicleClass": elements?.getValue(for: .jurisdictionVehicleClass),
+            "jurisdictionVehicleClassificationDescription": elements?.getValue(for: .jurisdictionVehicleClassificationDescription),
+            "jurisdictionVersionNumber": elements?.getValue(for: .jurisdictionVersionNumber),
+            "limitedDurationDocument": elements?.getValue(for: .limitedDurationDocument),
+            "medicalIndicator": elements?.getValue(for: .medicalIndicator),
+            "middleNameTruncation": elements?.getValue(for: .middleNameTruncation),
+            "namePrefix": elements?.getValue(for: .namePrefix),
+            "nameSuffix": elements?.getValue(for: .nameSuffix),
+            "nonResident": elements?.getValue(for: .nonResident),
+            "numberOfDuplicates": elements?.getValue(for: .numberOfDuplicates),
+            "organDonor": elements?.getValue(for: .organDonor),
+            "permitExpirationDate": elements?.getValue(for: .permitExpirationDate),
+            "permitIdentifier": elements?.getValue(for: .permitIdentifier),
+            "permitIssueDate": elements?.getValue(for: .permitIssueDate),
+            "placeOfBirth": elements?.getValue(for: .placeOfBirth),
+            "raceEthnicity": elements?.getValue(for: .raceEthnicity),
+            "residenceCity": elements?.getValue(for: .residenceCity),
+            "residenceFullAddress": elements?.getValue(for: .residenceFullAddress),
+            "residenceJurisdictionCode": elements?.getValue(for: .residenceJurisdictionCode),
+            "residencePostalCode": elements?.getValue(for: .residencePostalCode),
+            "residenceStreetAddress": elements?.getValue(for: .residenceStreetAddress),
+            "residenceStreetAddress2": elements?.getValue(for: .residenceStreetAddress2),
+            "securityVersion": elements?.getValue(for: .securityVersion),
+            "sex": elements?.getValue(for: .sex),
+            "socialSecurityNumber": elements?.getValue(for: .socialSecurityNumber),
+            "standardEndorsementCode": elements?.getValue(for: .standardEndorsementCode),
+            "standardRestrictionCode": elements?.getValue(for: .standardRestrictionCode),
+            "standardVehicleClassification": elements?.getValue(for: .standardVehicleClassification),
+            "standardVersionNumber": elements?.getValue(for: .standardVersionNumber),
+            "under18": elements?.getValue(for: .under18),
+            "under19": elements?.getValue(for: .under19),
+            "under21": elements?.getValue(for: .under21),
+            "uniqueCustomerId": elements?.getValue(for: .uniqueCustomerId),
+            "veteran": elements?.getValue(for: .veteran),
+            "weightKilograms": elements?.getValue(for: .weightKilograms),
+            "weightPounds": elements?.getValue(for: .weightPounds),
+            "weightRange": elements?.getValue(for: .weightRange),
+        ]
+    }
+
+    
+    static func serializeStringType<T>(_ value: T) -> Any? {
+        if let stringResult = value as? BlinkID.BlinkIDSDK.StringResult {
+            return serializeStringResult(stringResult)
+        } else if let str = value as? Swift.String {
+            return str
+        }
+        return nil
+    }
+    
+    static func encodeImage(_ image: UIImage?) -> String? {
+        return image?.jpegData(compressionQuality: 1.0)?.base64EncodedString()
+    }
+    static func serializeMrzResult(_ mrzResult: MRZResult?) -> Dictionary<String, Any?> {
+        return [
+            "rawMRZString": mrzResult?.rawMRZString,
+            "documentCode": mrzResult?.documentCode,
+            "issuer": mrzResult?.issuer,
+            "documentNumber": mrzResult?.documentNumber,
+            "opt1": mrzResult?.opt1,
+            "opt2": mrzResult?.opt2,
+            "gender": mrzResult?.gender,
+            "nationality": mrzResult?.nationality,
+            "primaryID": mrzResult?.primaryID,
+            "secondaryID": mrzResult?.secondaryID,
+            "issuerName": mrzResult?.issuerName,
+            "nationalityName": mrzResult?.nationalityName,
+            "verified": mrzResult?.verified,
+            "dateOfBirth": serializeDateResult(mrzResult?.dateOfBirth),
+            "dateOfExpiry": serializeDateResult(mrzResult?.dateOfExpiry),
+            "documentType": serializeMrzDocumentType(mrzResult?.documentType),
+            "sanitizedOpt1": mrzResult?.sanitizedOpt1,
+            "sanitizedOpt2": mrzResult?.sanitizedOpt2,
+            "sanitizedNationality": mrzResult?.sanitizedNationality,
+            "sanitizedIssuer": mrzResult?.sanitizedIssuer,
+            "sanitizedDocumentCode": mrzResult?.sanitizedDocumentCode,
+            "sanitizedDocumentNumber": mrzResult?.sanitizedDocumentNumber,
+        ]
+    }
+    
+    static func serializeMrzDocumentType(_ documentType: MRZDocumentType?) -> String? {
+        switch documentType {
+        case .unknown:
+            return "unknown"
+        case .identityCard:
+            return "identityCard"
+        case .passport:
+            return "passport"
+        case .visa:
+            return "visa"
+        case .greenCard:
+            return "greenCard"
+        case .mysPassIMM13P:
+            return "mysPassIMM13P"
+        case .driverLicense:
+            return "driverLicense"
+        case .internalTravelDocument:
+            return "internalTravelDocument"
+        case .borderCrossingCard:
+            return "borderCrossingCard"
+        case .none:
+            return nil
+        @unknown default:
+            return nil
+        }
+    }
+
+    static func serializeVizResult(_ vizResult: VIZResult?) -> Dictionary<String, Any> {
+        var vizResultDict = Dictionary<String, Any>()
+        if let vizResult {
+            if let firstName = vizResult.firstName {
+                vizResultDict["firstName"] = serializeStringResult(firstName)
+            }
+            if let lastName = vizResult.lastName {
+                vizResultDict["lastName"] = serializeStringResult(lastName)
+            }
+            if let fullName = vizResult.fullName {
+                vizResultDict["fullName"] = serializeStringResult(fullName)
+            }
+            if let additionalNameInformation = vizResult.additionalNameInformation {
+                vizResultDict["additionalNameInformation"] = serializeStringResult(additionalNameInformation)
+            }
+            if let localizedName = vizResult.localizedName {
+                vizResultDict["localizedName"] = serializeStringResult(localizedName)
+            }
+            if let fathersName = vizResult.fathersName {
+                vizResultDict["fathersName"] = serializeStringResult(fathersName)
+            }
+            if let mothersName = vizResult.mothersName {
+                vizResultDict["mothersName"] = serializeStringResult(mothersName)
+            }
+            if let address = vizResult.address {
+                vizResultDict["address"] = serializeStringResult(address)
+            }
+            if let additionalAddressInformation = vizResult.additionalAddressInformation {
+                vizResultDict["additionalAddressInformation"] = serializeStringResult(additionalAddressInformation)
+            }
+            if let additionalOptionalAddressInformation = vizResult.additionalOptionalAddressInformation {
+                vizResultDict["additionalOptionalAddressInformation"] = serializeStringResult(additionalOptionalAddressInformation)
+            }
+            if let placeOfBirth = vizResult.placeOfBirth {
+                vizResultDict["placeOfBirth"] = serializeStringResult(placeOfBirth)
+            }
+            if let nationality = vizResult.nationality {
+                vizResultDict["nationality"] = serializeStringResult(nationality)
+            }
+            if let race = vizResult.race {
+                vizResultDict["race"] = serializeStringResult(race)
+            }
+            if let religion = vizResult.religion {
+                vizResultDict["religion"] = serializeStringResult(religion)
+            }
+            if let profession = vizResult.profession {
+                vizResultDict["profession"] = serializeStringResult(profession)
+            }
+            if let maritalStatus = vizResult.maritalStatus {
+                vizResultDict["maritalStatus"] = serializeStringResult(maritalStatus)
+            }
+            if let residentialStatus = vizResult.residentialStatus {
+                vizResultDict["residentialStatus"] = serializeStringResult(residentialStatus)
+            }
+            if let sex = vizResult.sex {
+                vizResultDict["sex"] = serializeStringResult(sex)
+            }
+            if let employer = vizResult.employer {
+                vizResultDict["employer"] = serializeStringResult(employer)
+            }
+            if let sponsor = vizResult.sponsor {
+                vizResultDict["sponsor"] = serializeStringResult(sponsor)
+            }
+            if let bloodType = vizResult.bloodType {
+                vizResultDict["bloodType"] = serializeStringResult(bloodType)
+            }
+            if let dateOfBirth = vizResult.dateOfBirth {
+                vizResultDict["dateOfBirth"] = serializeDateResult(dateOfBirth)
+            }
+            if let dateOfIssue = vizResult.dateOfIssue {
+                vizResultDict["dateOfIssue"] = serializeDateResult(dateOfIssue)
+            }
+            if let dateOfExpiry = vizResult.dateOfExpiry {
+                vizResultDict["dateOfExpiry"] = serializeDateResult(dateOfExpiry)
+            }
+            if let dateOfEntry = vizResult.dateOfEntry {
+                vizResultDict["dateOfEntry"] = serializeDateResult(dateOfEntry)
+            }
+            vizResultDict["dateOfExpiryPermanent"] = vizResult.dateOfExpiryPermanent
+            if let effectiveDate = vizResult.effectiveDate {
+                vizResultDict["effectiveDate"] = serializeDateResult(effectiveDate)
+            }
+            if let documentNumber = vizResult.documentNumber {
+                vizResultDict["documentNumber"] = serializeStringResult(documentNumber)
+            }
+            if let cardAccessNumber = vizResult.cardAccessNumber {
+                vizResultDict["cardAccessNumber"] = serializeStringResult(cardAccessNumber)
+            }
+            if let personalIdNumber = vizResult.personalIdNumber {
+                vizResultDict["personalIdNumber"] = serializeStringResult(personalIdNumber)
+            }
+            if let documentAdditionalNumber = vizResult.documentAdditionalNumber {
+                vizResultDict["documentAdditionalNumber"] = serializeStringResult(documentAdditionalNumber)
+            }
+            if let documentOptionalAdditionalNumber = vizResult.documentOptionalAdditionalNumber {
+                vizResultDict["documentOptionalAdditionalNumber"] = serializeStringResult(documentOptionalAdditionalNumber)
+            }
+            if let additionalPersonalIdNumber = vizResult.additionalPersonalIdNumber {
+                vizResultDict["additionalPersonalIdNumber"] = serializeStringResult(additionalPersonalIdNumber)
+            }
+            if let issuingAuthority = vizResult.issuingAuthority {
+                vizResultDict["issuingAuthority"] = serializeStringResult(issuingAuthority)
+            }
+            if let visaType = vizResult.visaType {
+                vizResultDict["visaType"] = serializeStringResult(visaType)
+            }
+            if let certificateNumber = vizResult.certificateNumber {
+                vizResultDict["certificateNumber"] = serializeStringResult(certificateNumber)
+            }
+            if let countryCode = vizResult.countryCode {
+                vizResultDict["countryCode"] = serializeStringResult(countryCode)
+            }
+            if let driverLicenseDetailedInfo = vizResult.driverLicenseDetailedInfo {
+                vizResultDict["driverLicenseDetailedInfo"] = serializeDriverLicenseDetailedInfo(driverLicenseDetailedInfo)
+            }
+            if let documentSubtype = vizResult.documentSubtype {
+                vizResultDict["documentSubtype"] = serializeStringResult(documentSubtype)
+            }
+            if let remarks = vizResult.remarks {
+                vizResultDict["remarks"] = serializeStringResult(remarks)
+            }
+            if let residencePermitType = vizResult.residencePermitType {
+                vizResultDict["residencePermitType"] = serializeStringResult(residencePermitType)
+            }
+            if let manufacturingYear = vizResult.manufacturingYear {
+                vizResultDict["manufacturingYear"] = serializeStringResult(manufacturingYear)
+            }
+            if let nationalInsuranceNumber = vizResult.nationalInsuranceNumber {
+                vizResultDict["nationalInsuranceNumber"] = serializeStringResult(nationalInsuranceNumber)
+            }
+            if let vehicleType = vizResult.vehicleType {
+                vizResultDict["vehicleType"] = serializeStringResult(vehicleType)
+            }
+            if let eligibilityCategory = vizResult.eligibilityCategory {
+                vizResultDict["eligibilityCategory"] = serializeStringResult(eligibilityCategory)
+            }
+            if let specificDocumentValidity = vizResult.specificDocumentValidity {
+                vizResultDict["specificDocumentValidity"] = serializeStringResult(specificDocumentValidity)
+            }
+            if let dependentsInfo = vizResult.dependentsInfo {
+                vizResultDict["dependentsInfo"] = dependentsInfo.compactMap(serializeDependentInfo(_:))
+            }
+            if let vehicleOwner = vizResult.vehicleOwner {
+                vizResultDict["vehicleOwner"] = serializeStringResult(vehicleOwner)
+            }
+            if let parentsInfo = vizResult.parentsInfo {
+                vizResultDict["parentsInfo"] = parentsInfo.map(serializeParentInfo(_:))
+            }
+            if let localityCode = vizResult.localityCode {
+                vizResultDict["localityCode"] = serializeStringResult(localityCode)
+            }
+            if let maidenName = vizResult.maidenName {
+                vizResultDict["maidenName"] = serializeStringResult(maidenName)
+            }
+            if let municipalityCode = vizResult.municipalityCode {
+                vizResultDict["municipalityCode"] = serializeStringResult(municipalityCode)
+            }
+            if let municipalityOfRegistration = vizResult.municipalityOfRegistration {
+                vizResultDict["municipalityOfRegistration"] = serializeStringResult(municipalityOfRegistration)
+            }
+            if let pollingStationCode = vizResult.pollingStationCode {
+                vizResultDict["pollingStationCode"] = serializeStringResult(pollingStationCode)
+            }
+            if let registrationCenterCode = vizResult.registrationCenterCode {
+                vizResultDict["registrationCenterCode"] = serializeStringResult(registrationCenterCode)
+            }
+            if let sectionCode = vizResult.sectionCode {
+                vizResultDict["sectionCode"] = serializeStringResult(sectionCode)
+            }
+            if let stateCode = vizResult.stateCode {
+                vizResultDict["stateCode"] = serializeStringResult(stateCode)
+            }
+            if let stateName = vizResult.stateName {
+                vizResultDict["stateName"] = serializeStringResult(stateName)
+            }
+            if let husbandName = vizResult.husbandName {
+                vizResultDict["husbandName"] = serializeStringResult(husbandName)
+            }
+            if let legalStatus = vizResult.legalStatus {
+                vizResultDict["legalStatus"] = serializeStringResult(legalStatus)
+            }
+            if let socialSecurityStatus = vizResult.socialSecurityStatus {
+                vizResultDict["socialSecurityStatus"] = serializeStringResult(socialSecurityStatus)
+            }
+            if let workRestriction = vizResult.workRestriction {
+                vizResultDict["workRestriction"] = serializeStringResult(workRestriction)
+            }
+        }
+        return vizResultDict
+    }
+    
+    static func serializeDetailedCroppedImageResult(_ detailedcroppedImageResult: DetailedCroppedImageResult?) -> Dictionary<String, Any?> {
+        return [
+            "location": serializeRect(detailedcroppedImageResult?.location),
+            "side": serializeScanningSide(detailedcroppedImageResult?.side),
+            "image": encodeImage(detailedcroppedImageResult?.uiImage)
+        ]
+    }
+    
+    static func serializeScanningSide(_ side: ScanningSide?) -> String? {
+        switch side {
+        case .first:
+            return "first"
+        case .second:
+            return "second"
+        case .none:
+            return nil
+        @unknown default:
+            return nil
+        }
+    }
+    
+    static func deserializeDataMatchState(_ state: DataMatchState?) -> String {
+        switch state {
+        case .notPerformed: return "notPerformed"
+        case .failed: return "failed"
+        case .success: return "success"
+        case .none: return "none"
+        @unknown default: return "none"
+        }
+    }
+    
+    static func serializeParentInfo(_ parentInfo: ParentInfo) -> Dictionary<String, Any> {
+        var parentInfoDict: [String: Any] = [:]
+        if let firstName = parentInfo.firstName {
+            parentInfoDict["firstName"] = serializeStringResult(firstName)
+        }
+        if let lastName = parentInfo.lastName {
+            parentInfoDict["lastName"] = serializeStringResult(lastName)
+        }
+        return parentInfoDict
+    }
+    
+    static func encodeToJson(_ dict: Dictionary<String, Any>) -> String? {
+        do {
+            let jsonData = try JSONSerialization.data(withJSONObject: dict, options: .prettyPrinted)
+            let resultForJson = String(data: jsonData, encoding: .utf8)
+            return resultForJson
+        } catch {
+            return ""
+        }
+    }
+}