@microblink/blinkid-react-native 7.2.0

package/ios/BlinkIdSerializationUtilities.swift

@@ -0,0 +1,675 @@
+//
+//  BlinkIdSerializationUtilities.swift
+//  BlinkidReactNative
+//
+//  Created by Milan Parađina on 22.05.2025..
+//
+
+import Foundation
+import BlinkID
+
+class BlinkIdSerializationUtilities {
+  static func serializeBlinkIdScanningResult(_ scanningResult: BlinkIDScanningResult?) -> String? {
+      var scanningResultDict = Dictionary<String, Any>()
+      
+      if let recognitionMode = scanningResult?.recognitionMode {
+        scanningResultDict["recognitionMode"] = recognitionMode.rawValue
+      }
+      if let documentClassInfo = scanningResult?.documentClassInfo {
+          scanningResultDict["documentClassInfo"] = serializeDocumentClassInfo(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 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 dateOfExpiryPermanent = scanningResult?.dateOfExpiryPermanent {
+          scanningResultDict["dateOfExpiryPermanent"] = dateOfExpiryPermanent
+      }
+      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 driverLicenseDetailedInfo = scanningResult?.driverLicenseDetailedInfo {
+          scanningResultDict["driverLicenseDetailedInfo"] = serializeDriverLicenseDetailedInfo(driverLicenseDetailedInfo)
+      }
+      if let dependentsInfo = scanningResult?.dependentsInfo {
+          scanningResultDict["dependentsInfo"] = dependentsInfo.map(serializeDependentInfo(_:))
+      }
+      if let subResults = scanningResult?.subResults {
+          scanningResultDict["subResults"] = 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 barcodeInputImage = scanningResult?.getBarcodeInputImage() {
+          scanningResultDict["barcodeInputImage"] = encodeImage(barcodeInputImage.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> {
+      let classInfoDict: [String: Any?] = [
+          "country": documentClassInfo?.country.rawValue,
+          "region": documentClassInfo?.region.rawValue,
+          "documentType": documentClassInfo?.documentType.rawValue,
+          "countryName": documentClassInfo?.countryName,
+          "isoNumericCountryCode": documentClassInfo?.isoNumericCountryCode,
+          "isoAlpha2CountryCode": documentClassInfo?.isoAlpha2CountryCode,
+          "isoAlpha3CountryCode": documentClassInfo?.isoAlpha3CountryCode,
+          "isEmpty": documentClassInfo?.isEmpty()
+      ]
+      return classInfoDict.compactMapValues { $0 }
+  }
+  
+  static func serializeDataMatchResult(_ dataMatchResult: DataMatchResult?) -> Dictionary<String, Any> {
+      let dataMatchResultDict: [String: Any?] = [
+          "states": dataMatchResult?.states.map(serializeDataMatchState(_:)),
+          "overallState": serializeDataMatchState(dataMatchResult?.overallState)
+      ]
+      
+      return dataMatchResultDict.compactMapValues{ $0 }
+  }
+  
+  static func serializeDataMatchState(_ dataMatchState: FieldState?) -> Dictionary<String, Any> {
+      [
+        "field": serializeDataMatchField(dataMatchState?.fieldType),
+          "state": serializeDataMatchState(dataMatchState?.state)
+      ].compactMapValues { $0 }
+  }
+  
+  static func serializeStringResult(_ stringResult: BlinkIDSDK.StringResult?) -> Dictionary<String, Any>{
+      var stringResultDict: [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)
+      ]
+              
+      let locationDict: [String: Any?] = [
+          "latin": serializeRect(stringResult?.location(for: .latin)),
+          "arabic": serializeRect(stringResult?.location(for: .arabic)),
+          "cyrillic": serializeRect(stringResult?.location(for: .cyrillic)),
+          "greek": serializeRect(stringResult?.location(for: .greek))
+      ].compactMapValues { $0 }
+      
+      stringResultDict["location"] = locationDict
+      
+      let sideDict: [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))
+      ].compactMapValues { $0 }
+      
+      stringResultDict["side"] = sideDict
+      
+      return stringResultDict.compactMapValues { $0 }
+  }
+  
+  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>? {
+      let dateResultDict: [String: Any?] = [
+        "date": serializeSimpleDate(dateResult),
+          "filledByDomainKnowledge": dateResult?.filledByDomainKnowledge,
+          "successfullyParsed": dateResult?.successfullyParsed,
+          "originalString": serializeStringType(dateResult?.originalString)
+      ]
+      return dateResultDict.compactMapValues { $0 }
+  }
+  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>? {
+      let driverLicenseDetailedInfoDict: [String: Any?] = [
+          "conditions": serializeStringType(driverLicenseDetailedInfo?.conditions),
+          "endorsements": serializeStringType(driverLicenseDetailedInfo?.endorsements),
+          "restrictions": serializeStringType(driverLicenseDetailedInfo?.restrictions),
+          "vehicleClass": serializeStringType(driverLicenseDetailedInfo?.vehicleClass),
+          "vehicleClassesInfo": driverLicenseDetailedInfo?.vehicleClassesInfo?.map(serializeVehicleClassInfo(_:)),
+      ]
+      
+      return driverLicenseDetailedInfoDict.compactMapValues { $0 }
+  }
+  
+  static func serializeVehicleClassInfo<T>(_ vehicleClassInfo: VehicleClassInfo<T>?) -> Dictionary<String, Any> {
+      let vehicleClassInfoDict: [String: Any?] = [
+          "effectiveDate": serializeStringType(vehicleClassInfo?.effectiveDate),
+          "expiryDate":  serializeStringType(vehicleClassInfo?.expiryDate),
+          "licenceType": serializeStringType(vehicleClassInfo?.licenceType),
+          "vehicleClass": serializeStringType(vehicleClassInfo?.vehicleClass as? String)
+      ]
+      return vehicleClassInfoDict.compactMapValues { $0 }
+  }
+  static func serializeDependentInfo(_ dependentInfo: DependentInfo?) -> Dictionary<String, Any> {
+      let dependentInfoDict: [String: Any?] = [
+          "dateOfBirth": serializeDateResult(dependentInfo?.dateOfBirth),
+          "documentNumber": serializeStringResult(dependentInfo?.documentNumber),
+          "fullName": serializeStringResult(dependentInfo?.fullName),
+          "sex": serializeStringResult(dependentInfo?.sex)
+      ]
+      return dependentInfoDict.compactMapValues { $0 }
+  }
+  
+  static func serializeSingleSideScanningResult(_ singleSideScanningResult: SingleSideScanningResult?) -> Dictionary<String, Any> {
+      let singleSideScanningDict: [String: Any?] = [
+              "barcode": serializeBarcodeResult(singleSideScanningResult?.barcode),
+              "barcodeInputImage": encodeImage(singleSideScanningResult?.barcodeInputImage?.uiImage),
+              "documentImage": encodeImage(singleSideScanningResult?.documentImage?.uiImage),
+              "faceImage": serializeDetailedCroppedImageResult(singleSideScanningResult?.faceImage),
+              "inputImage": encodeImage(singleSideScanningResult?.inputImage?.uiImage),
+              "mrz": serializeMrzResult(singleSideScanningResult?.mrz),
+              "signatureImage": serializeDetailedCroppedImageResult(singleSideScanningResult?.signatureImage),
+              "viz": serializeVizResult(singleSideScanningResult?.viz)
+          ]
+      
+      return singleSideScanningDict.compactMapValues { $0 }
+  }
+  
+  static func serializeBarcodeResult(_ barcodeResult: BarcodeResult?) -> Dictionary<String, Any> {
+      let barcodeResultDict: [String: Any?] = [
+          "additionalNameInformation": barcodeResult?.additionalNameInformation,
+          "address": barcodeResult?.address,
+          "addressDetailedInfo": serializeAddressDetailedInfo(barcodeResult?.addressDetailedInfo),
+          "barcodeData": serializeBarcodeData(barcodeResult?.barcodeData),
+          "dateOfBirth": serializeDateResult(barcodeResult?.dateOfBirth),
+          "dateOfExpiry": serializeDateResult(barcodeResult?.dateOfExpiry),
+          "dateOfIssue": serializeDateResult(barcodeResult?.dateOfIssue),
+          "documentAdditionalNumber": barcodeResult?.documentAdditionalNumber,
+          "documentNumber": barcodeResult?.documentNumber,
+          "driverLicenseDetailedInfo": serializeDriverLicenseDetailedInfo(barcodeResult?.driverLicenseDetailedInfo),
+          "employer": barcodeResult?.employer,
+          "extendedElements": serializeBarcodeExtendedElements(barcodeResult?.extendedElements),
+          "firstName": barcodeResult?.firstName,
+          "fullName": barcodeResult?.fullName,
+          "issuingAuthority": barcodeResult?.issuingAuthority,
+          "lastName": barcodeResult?.lastName,
+          "maritalStatus": barcodeResult?.maritalStatus,
+          "middleName": barcodeResult?.middleName,
+          "nationality": barcodeResult?.nationality,
+          "personalIdNumber": barcodeResult?.personalIdNumber,
+          "placeOfBirth": barcodeResult?.placeOfBirth,
+          "profession": barcodeResult?.profession,
+          "race": barcodeResult?.race,
+          "religion": barcodeResult?.religion,
+          "residentialStatus": barcodeResult?.residentialStatus,
+          "sex": barcodeResult?.sex
+      ]
+      
+      return barcodeResultDict.compactMapValues { $0 }
+  }
+  
+  static func serializeAddressDetailedInfo(_ addressDetailedInfo: AddressDetailedInfo?) -> Dictionary<String, Any> {
+      let addressDetailedInfoDict: [String: Any?] = [
+          "city": addressDetailedInfo?.city,
+          "postalCode": addressDetailedInfo?.postalCode,
+          "jurisdiction": addressDetailedInfo?.jurisdiction,
+          "street": addressDetailedInfo?.street
+      ]
+      return addressDetailedInfoDict.compactMapValues { $0 }
+  }
+    
+  static func serializeBarcodeData(_ barcodeData: BarcodeData?) -> Dictionary<String, Any> {
+      let barcodeDataDict: [String: Any?] = [
+        "barcodeType": serializeBarcodeType(barcodeData?.barcodeType),
+          "rawData": barcodeData?.rawData.base64EncodedString(),
+          "stringData": barcodeData?.stringData,
+          "uncertain": barcodeData?.uncertain
+      ]
+      
+      return barcodeDataDict.compactMapValues { $0 }
+  }
+  
+  static func serializeBarcodeExtendedElements(_ barcodeExtendedElements: BarcodeElements?) -> [String: Any] {
+      var elements = barcodeExtendedElements
+      
+      let barcodeElementDict: [String: Any?] = [
+          "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),
+      ]
+      return barcodeElementDict.compactMapValues { $0 }
+  }
+
+  
+  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> {
+      let mrzResultDict: [String: Any?] = [
+          "dateOfBirth": serializeDateResult(mrzResult?.dateOfBirth),
+          "dateOfExpiry": serializeDateResult(mrzResult?.dateOfExpiry),
+          "documentCode": mrzResult?.documentCode,
+          "documentNumber": mrzResult?.documentNumber,
+          "documentType": serializeMrzDocumentType(mrzResult?.documentType),
+          "gender": mrzResult?.gender,
+          "issuer": mrzResult?.issuer,
+          "issuerName": mrzResult?.issuerName,
+          "nationality": mrzResult?.nationality,
+          "nationalityName": mrzResult?.nationalityName,
+          "opt1": mrzResult?.opt1,
+          "opt2": mrzResult?.opt2,
+          "primaryID": mrzResult?.primaryID,
+          "rawMRZString": mrzResult?.rawMRZString,
+          "sanitizedDocumentCode": mrzResult?.sanitizedDocumentCode,
+          "sanitizedDocumentNumber": mrzResult?.sanitizedDocumentNumber,
+          "sanitizedIssuer": mrzResult?.sanitizedIssuer,
+          "sanitizedNationality": mrzResult?.sanitizedNationality,
+          "sanitizedOpt1": mrzResult?.sanitizedOpt1,
+          "sanitizedOpt2": mrzResult?.sanitizedOpt2,
+          "secondaryID": mrzResult?.secondaryID,
+          "verified": mrzResult?.verified
+      ]
+      
+      return mrzResultDict.compactMapValues { $0 }
+  }
+  
+  static func serializeVizResult(_ vizResult: VIZResult?) -> Dictionary<String, Any> {
+      
+      let vizResultDict: [String: Any?] =
+       [
+          "additionalAddressInformation": serializeStringResult(vizResult?.additionalAddressInformation),
+          "additionalNameInformation": serializeStringResult(vizResult?.additionalNameInformation),
+          "additionalOptionalAddressInformation": serializeStringResult(vizResult?.additionalOptionalAddressInformation),
+          "additionalPersonalIdNumber": serializeStringResult(vizResult?.additionalPersonalIdNumber),
+          "address": serializeStringResult(vizResult?.address),
+          "bloodType": serializeStringResult(vizResult?.bloodType),
+          "dateOfBirth": serializeDateResult(vizResult?.dateOfBirth),
+          "dateOfExpiry": serializeDateResult(vizResult?.dateOfExpiry),
+          "dateOfExpiryPermanent": vizResult?.dateOfExpiryPermanent,
+          "dateOfIssue": serializeDateResult(vizResult?.dateOfIssue),
+          "dependentsInfo": vizResult?.dependentsInfo.compactMap(serializeDependentInfo(_:)),
+          "documentAdditionalNumber": serializeStringResult(vizResult?.documentAdditionalNumber),
+          "documentNumber": serializeStringResult(vizResult?.documentNumber),
+          "documentOptionalAdditionalNumber": serializeStringResult(vizResult?.documentOptionalAdditionalNumber),
+          "documentSubtype": serializeStringResult(vizResult?.documentSubtype),
+          "driverLicenseDetailedInfo": serializeDriverLicenseDetailedInfo(vizResult?.driverLicenseDetailedInfo),
+          "eligibilityCategory": serializeStringResult(vizResult?.eligibilityCategory),
+          "employer": serializeStringResult(vizResult?.employer),
+          "fathersName": serializeStringResult(vizResult?.fathersName),
+          "firstName": serializeStringResult(vizResult?.firstName),
+          "fullName": serializeStringResult(vizResult?.fullName),
+          "issuingAuthority": serializeStringResult(vizResult?.issuingAuthority),
+          "lastName": serializeStringResult(vizResult?.lastName),
+          "localizedName": serializeStringResult(vizResult?.localizedName),
+          "manufacturingYear": serializeStringResult(vizResult?.manufacturingYear),
+          "maritalStatus": serializeStringResult(vizResult?.maritalStatus),
+          "mothersName": serializeStringResult(vizResult?.mothersName),
+          "nationality": serializeStringResult(vizResult?.nationality),
+          "personalIdNumber": serializeStringResult(vizResult?.personalIdNumber),
+          "placeOfBirth": serializeStringResult(vizResult?.placeOfBirth),
+          "profession": serializeStringResult(vizResult?.profession),
+          "race": serializeStringResult(vizResult?.race),
+          "religion": serializeStringResult(vizResult?.religion),
+          "remarks": serializeStringResult(vizResult?.remarks),
+          "residencePermitType": serializeStringResult(vizResult?.residencePermitType),
+          "residentialStatus": serializeStringResult(vizResult?.residentialStatus),
+          "sex": serializeStringResult(vizResult?.sex),
+          "specificDocumentValidity": serializeStringResult(vizResult?.specificDocumentValidity),
+          "sponsor": serializeStringResult(vizResult?.sponsor),
+          "vehicleOwner": serializeStringResult(vizResult?.vehicleOwner),
+          "vehicleType": serializeStringResult(vizResult?.vehicleType),
+          "visaType": serializeStringResult(vizResult?.visaType)
+      ]
+      
+      return vizResultDict.compactMapValues { $0 }
+  }
+  
+  static func serializeDetailedCroppedImageResult(_ detailedcroppedImageResult: DetailedCroppedImageResult?) -> Dictionary<String, Any> {
+      let detailedcroppedImageResultDict: [String: Any?] = [
+          "location": serializeRect(detailedcroppedImageResult?.location),
+          "side": serializeScanningSide(detailedcroppedImageResult?.side),
+          "image": encodeImage(detailedcroppedImageResult?.uiImage)
+      ]
+      return detailedcroppedImageResultDict.compactMapValues { $0 }
+  }
+  
+  static func serializeDataMatchState(_ state: DataMatchState?) -> Int {
+      switch state {
+      case .notPerformed:
+          return 0
+      case .failed:
+          return 1
+      case .success:
+          return 2
+      case .none:
+          return 0
+      @unknown default:
+          return 0
+      }
+  }
+  
+  static func serializeDataMatchField(_ field: DataMatchFieldType?) -> Int? {
+      switch field {
+      case .dateOfBirth:
+          return 0
+      case .dateOfExpiry:
+          return 1
+      case .documentNumber:
+          return 2
+      case .documentAdditionalNumber:
+          return 3
+      case .documentOptionalAdditionalNumber:
+          return 4
+      case .personalIdNumber:
+          return 5
+      case .none:
+          return 0
+      @unknown default:
+          return nil
+      }
+  }
+  
+  static func serializeScanningSide(_ side: ScanningSide?) -> Int? {
+      switch side {
+      case .first:
+          return 0
+      case .second:
+          return 1
+      case .none:
+          return nil
+      @unknown default:
+          return nil
+      }
+  }
+  
+  static func serializeBarcodeType(_ barcodeType: BarcodeType?) -> Int? {
+      switch barcodeType {
+      case BarcodeType?.none:
+          return 0
+      case .qrCode:
+          return 1
+      case .dataMatrix:
+          return 2
+      case .upce:
+          return 3
+      case .upca:
+          return 4
+      case .ean8:
+          return 5
+      case .ean13:
+          return 6
+      case .code128:
+          return 7
+      case .code39:
+          return 8
+      case .itf:
+          return 9
+      case .aztec:
+          return 10
+      case .pdf417:
+          return 11
+      case .some(.none):
+          return 0
+      @unknown default:
+          return 0
+      }
+  }
+  
+  static func serializeMrzDocumentType(_ documentType: MRZDocumentType?) -> Int? {
+      switch documentType {
+      case .unknown:
+          return 0
+      case .identityCard:
+          return 1
+      case .passport:
+          return 2
+      case .visa:
+          return 3
+      case .greenCard:
+          return 4
+      case .mysPassIMM13P:
+          return 5
+      case .driverLicense:
+          return 6
+      case .internalTravelDocument:
+          return 7
+      case .borderCrossingCard:
+          return 8
+      case .none:
+          return 0
+      @unknown default:
+          return nil
+      }
+  }
+  
+  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 ""
+      }
+  }
+}

package/ios/BlinkidReactNative.h

@@ -0,0 +1,6 @@
+#import <BlinkidReactNativeSpec/BlinkidReactNativeSpec.h>
+
+@interface BlinkidReactNative : NSObject <NativeBlinkidReactNativeSpec>
+- (NSDictionary *)createDictionaryFromBlinkIdObject:(NSString *)jsonString;
+
+@end