@regulaforensics/react-native-document-reader-api 6.4.0 → 6.6.0

package/ios/RGLWJSONConstructor.h

@@ -12,6 +12,7 @@
 +(NSMutableDictionary* _Nonnull)generateNSDictionary:(NSDictionary<NSNumber*, NSNumber*>* _Nullable)input;
 +(RGLPKDCertificate* _Nullable)RGLPKDCertificateFromJson:(NSDictionary* _Nullable) dict;
 +(RGLTCCParams* _Nonnull)RGLTCCParamsFromJson:(NSDictionary* _Nonnull)input;
++(RGLConfig* _Nullable)RGLConfigFromJson:(NSDictionary* _Nonnull)input;
 +(RGLImageInput* _Nonnull)RGLImageInputFromJson:(NSDictionary* _Nonnull)input;
 +(NSInteger)generateDocReaderAction:(RGLDocReaderAction)action;
 +(NSInteger)generateRFIDCompleteAction:(RGLRFIDCompleteAction)action;
@@ -64,6 +65,12 @@
 +(NSMutableDictionary* _Nonnull)generateRGLBytesData:(RGLBytesData* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLRFIDNotify:(RGLRFIDNotify* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLUVFiberElement:(RGLUVFiberElement* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocReaderDocumentsDatabase:(RGLDocReaderDocumentsDatabase* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderComparison:(RGLDocumentReaderComparison* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderValidity:(RGLDocumentReaderValidity* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderSymbol:(RGLDocumentReaderSymbol* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderTextSource:(RGLDocumentReaderTextSource* _Nullable)input;
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderRfidOrigin:(RGLDocumentReaderRfidOrigin* _Nullable)input;
 +(NSMutableDictionary* _Nonnull)generateRGLElementRect:(RGLElementRect* _Nullable)input;
 
 @end

package/ios/RGLWJSONConstructor.m

@@ -35,6 +35,28 @@
     return [[RGLTCCParams alloc] initWithServiceTAURLString:serviceTAURLString servicePAURLString:servicePAURLString pfxCertURLString:pfxCertURLString pfxCertData: pfxCertData pfxPassPhrase:pfxPassPhrase];
 }
 
++(RGLConfig*)RGLConfigFromJson:(NSDictionary*)input {
+    NSData* license;
+    if([input valueForKey:@"license"] != nil)
+        license = [[NSData alloc] initWithBase64EncodedString:[input valueForKey:@"license"] options:0];
+    else return nil;
+
+    RGLConfig *config = [[RGLConfig alloc] initWithLicenseData:license];
+
+    if([input valueForKey:@"databasePath"] != nil){
+        config.databasePath = [[input valueForKey:@"databasePath"] stringValue];
+    }
+    if([input valueForKey:@"licenseUpdate"] != nil){
+        config.licenseUpdateCheck = [[input valueForKey:@"licenseUpdate"] boolValue];
+    }
+    if([input valueForKey:@"delayedNNLoad"] != nil){
+        config.delayedNNLoadEnabled = [[input valueForKey:@"delayedNNLoad"] boolValue];
+    }
+
+    return config;
+}
+
+
 +(RGLImageInput*)RGLImageInputFromJson:(NSDictionary*)input {
     NSInteger pageIndex = 0;
     if([input valueForKey:@"pageIndex"] != nil)
@@ -294,11 +316,9 @@
                 [array addObject:[self generateRGLImageQualityGroup:item]];
         result[@"imageQuality"] = array;
     }
-    result[@"overallResult"] = @(input.overallResult);
     result[@"authenticityResult"] = [self generateRGLDocumentReaderAuthenticityResult:input.authenticityResults];
     result[@"rfidSessionData"] = [self generateRGLRFIDSessionData:input.rfidSessionData];
     result[@"chipPage"] = @(input.chipPage);
-    result[@"resolutionType"] = @(input.resolutionType);
     result[@"barcodeResult"] = [self generateRGLDocumentReaderBarcodeResult:input.barcodeResult];
     result[@"processingFinishedStatus"] = @(input.processingFinishedStatus);
     result[@"morePagesAvailable"] = @(input.morePagesAvailable);
@@ -494,6 +514,15 @@
         result[@"fields"] = array;
     }
     result[@"status"] = @(input.status);
+    result[@"comparisonStatus"] = @(input.comparisonStatus);
+    result[@"validityStatus"] = @(input.validityStatus);
+    if(input.availableSourceList != nil){
+        NSMutableArray *array = [NSMutableArray new];
+        for(RGLDocumentReaderTextSource* item in input.availableSourceList)
+            if(item != nil)
+                [array addObject:[self generateRGLDocumentReaderTextSource:item]];
+        result[@"availableSourceList"] = array;
+    }
 
     return result;
 }
@@ -514,7 +543,22 @@
         result[@"values"] = array;
     }
     result[@"status"] = @(input.status);
-    result[@"value"] = [self generateRGLDocumentReaderValue:[input getValue]];
+    result[@"value"] = input.value;
+    result[@"getValue"] = [self generateRGLDocumentReaderValue:[input getValue]];
+    if(input.comparisonList != nil){
+        NSMutableArray *array = [NSMutableArray new];
+        for(RGLDocumentReaderComparison* item in input.comparisonList)
+            if(item != nil)
+                [array addObject:[self generateRGLDocumentReaderComparison:item]];
+        result[@"comparisonList"] = array;
+    }
+    if(input.validityList != nil){
+        NSMutableArray *array = [NSMutableArray new];
+        for(RGLDocumentReaderValidity* item in input.validityList)
+            if(item != nil)
+                [array addObject:[self generateRGLDocumentReaderValidity:item]];
+        result[@"validityList"] = array;
+    }
 
     return result;
 }
@@ -531,6 +575,14 @@
     result[@"comparison"] = [self generateNSDictionary:input.comparison];
     result[@"pageIndex"] = @(input.pageIndex);
     result[@"probability"] = @(input.probability);
+    if(input.originalSymbols != nil){
+        NSMutableArray *array = [NSMutableArray new];
+        for(RGLDocumentReaderSymbol* item in input.originalSymbols)
+            if(item != nil)
+                [array addObject:[self generateRGLDocumentReaderSymbol:item]];
+        result[@"originalSymbols"] = array;
+    }
+    result[@"rfidOrigin"] = [self generateRGLDocumentReaderRfidOrigin:input.rfidOrigin];
 
     return result;
 }
@@ -614,7 +666,6 @@
     result[@"status"] = @(input.status);
     result[@"extLeSupport"] = @(input.extLeSupport);
     result[@"processTime"] = @(input.processTime);
-    result[@"sessionDataStatus"] = [self generateRGLRFIDSessionDataStatus:input.sessionDataStatus];
 
     return result;
 }
@@ -1110,6 +1161,75 @@
     return result;
 }
 
++(NSMutableDictionary* _Nonnull)generateRGLDocReaderDocumentsDatabase:(RGLDocReaderDocumentsDatabase* _Nullable)input {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if(input == nil) return result;
+
+    result[@"databaseID"] = input.databaseID;
+    result[@"version"] = input.version;
+    result[@"date"] = input.date;
+    result[@"databaseDescription"] = input.databaseDescription;
+    result[@"countriesNumber"] = @(input.countriesNumber);
+    result[@"documentsNumber"] = @(input.documentsNumber);
+
+    return result;
+}
+
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderComparison:(RGLDocumentReaderComparison* _Nullable)input {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if(input == nil) return result;
+
+    result[@"sourceTypeLeft"] = @(input.sourceTypeLeft);
+    result[@"sourceTypeRight"] = @(input.sourceTypeRight);
+    result[@"status"] = @(input.status);
+
+    return result;
+}
+
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderValidity:(RGLDocumentReaderValidity* _Nullable)input {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if(input == nil) return result;
+
+    result[@"sourceType"] = @(input.sourceType);
+    result[@"status"] = @(input.status);
+
+    return result;
+}
+
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderSymbol:(RGLDocumentReaderSymbol* _Nullable)input {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if(input == nil) return result;
+
+    result[@"code"] = @(input.code);
+    result[@"rect"] = [self generateCGRect:input.rect];
+    result[@"probability"] = @(input.probability);
+
+    return result;
+}
+
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderTextSource:(RGLDocumentReaderTextSource* _Nullable)input {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if(input == nil) return result;
+
+    result[@"sourceType"] = @(input.sourceType);
+    result[@"source"] = input.source;
+    result[@"validityStatus"] = @(input.validityStatus);
+
+    return result;
+}
+
++(NSMutableDictionary* _Nonnull)generateRGLDocumentReaderRfidOrigin:(RGLDocumentReaderRfidOrigin* _Nullable)input {
+    NSMutableDictionary *result = [NSMutableDictionary new];
+    if(input == nil) return result;
+
+    result[@"dg"] = @(input.dg);
+    result[@"dgTag"] = @(input.dgTag);
+    result[@"entryView"] = @(input.entryView);
+    result[@"tagEntry"] = @(input.tagEntry);
+
+    return result;
+}
+
 +(NSMutableDictionary* _Nonnull)generateRGLElementRect:(RGLElementRect* _Nullable)input {
     NSMutableDictionary *result = [NSMutableDictionary new];
     if(input == nil) return result;

package/ios/RNRegulaDocumentReader.m

@@ -5,6 +5,9 @@ NSString* rfidNotificationCompletionEvent = @"rfidNotificationCompletionEvent";
 NSString* paCertificateCompletionEvent = @"paCertificateCompletionEvent";
 NSString* taCertificateCompletionEvent = @"taCertificateCompletionEvent";
 NSString* taSignatureCompletionEvent = @"taSignatureCompletionEvent";
+NSString* bleOnServiceConnectedEvent = @"bleOnServiceConnectedEvent";
+NSString* bleOnServiceDisconnectedEvent = @"bleOnServiceDisconnectedEvent";
+NSString* bleOnDeviceReadyEvent = @"bleOnDeviceReadyEvent";
 RGLRFIDCertificatesCallback paCertificateCompletion;
 RGLRFIDCertificatesCallback taCertificateCompletion;
 RFIDDelegateNoPA* rfidDelegateNoPA;
@@ -47,7 +50,10 @@ RCT_EXPORT_MODULE();
              rfidNotificationCompletionEvent,
              paCertificateCompletionEvent,
              taCertificateCompletionEvent,
-             taSignatureCompletionEvent];
+             taSignatureCompletionEvent,
+             bleOnServiceConnectedEvent,
+             bleOnServiceDisconnectedEvent,
+             bleOnDeviceReadyEvent];
 }
 
 static NSNumber* _databasePercentageDownloaded;
@@ -130,6 +136,14 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
 
     if([action isEqualToString:@"initializeReaderAutomatically"])
         [self initializeReaderAutomatically :successCallback :errorCallback];
+    else if([action isEqualToString:@"isBlePermissionsGranted"])
+        [self isBlePermissionsGranted :successCallback :errorCallback];
+    else if([action isEqualToString:@"startBluetoothService"])
+        [self startBluetoothService :successCallback :errorCallback];
+    else if([action isEqualToString:@"initializeReaderBleDeviceConfig"])
+        [self initializeReaderBleDeviceConfig :successCallback :errorCallback];
+    else if([action isEqualToString:@"getTag"])
+        [self getTag :successCallback :errorCallback];
     else if([action isEqualToString:@"getAPIVersion"])
         [self getAPIVersion :successCallback :errorCallback];
     else if([action isEqualToString:@"getAvailableScenarios"])
@@ -210,6 +224,10 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
         [self addPKDCertificates :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"setCameraSessionIsPaused"])
         [self setCameraSessionIsPaused :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"setTag"])
+        [self setTag :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"checkDatabaseUpdate"])
+        [self checkDatabaseUpdate :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"getScenario"])
         [self getScenario :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeImages"])
@@ -228,6 +246,8 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
         [self prepareDatabase :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeImage"])
         [self recognizeImage :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"recognizeData"])
+        [self recognizeData :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"setRfidSessionStatus"])
         [self setRfidSessionStatus :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"providePACertificates"])
@@ -240,8 +260,6 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
         [self parseCoreResults :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"setTCCParams"])
         [self setTCCParams :[args objectAtIndex:0] :successCallback :errorCallback];
-    else if([action isEqualToString:@"initializeReaderWithDatabase"])
-        [self initializeReaderWithDatabase :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeImageWithOpts"])
         [self recognizeImageWithOpts :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeVideoFrame"])
@@ -262,6 +280,18 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
     [RGLDocReader.shared initializeReaderWithConfig:[RGLConfig configWithLicenseData:licenseData] completion:[self getInitCompletion :successCallback :errorCallback]];
 }
 
+- (void) isBlePermissionsGranted:(Callback)successCallback :(Callback)errorCallback{
+    [self result:@"isBlePermissionsGranted() is an android-only method" :errorCallback];
+}
+
+- (void) startBluetoothService:(Callback)successCallback :(Callback)errorCallback{
+    [self result:@"startBluetoothService() is an android-only method" :errorCallback];
+}
+
+- (void) initializeReaderBleDeviceConfig:(Callback)successCallback :(Callback)errorCallback{
+    [self result:@"initializeReaderBleDeviceConfig() is an android-only method" :errorCallback];
+}
+
 - (void) resetConfiguration:(Callback)successCallback :(Callback)errorCallback{
     [self result:@"resetConfiguration() is an android-only method" :errorCallback];
 }
@@ -296,12 +326,8 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
     [self result:@"getLicenseMessage() is an android-only method" :successCallback];
 }
 
-- (void) initializeReaderWithDatabase:(NSString*)licenseString :(NSString*)databaseString :(Callback)successCallback :(Callback)errorCallback{
-    [self result:@"initializeReaderWithDatabase() is an android-only method" :successCallback];
-}
-
-- (void) initializeReader:(NSString*)licenseString :(Callback)successCallback :(Callback)errorCallback{
-    [RGLDocReader.shared initializeReaderWithConfig:[RGLConfig configWithLicenseData:[[NSData alloc] initWithBase64EncodedString:licenseString options:0]] completion:[self getInitCompletion :successCallback :errorCallback]];
+- (void) initializeReader:(NSDictionary*)config :(Callback)successCallback :(Callback)errorCallback{
+    [RGLDocReader.shared initializeReaderWithConfig:[RGLWJSONConstructor RGLConfigFromJson:config] completion:[self getInitCompletion :successCallback :errorCallback]];
 }
 
 - (void) parseCoreResults:(NSString*)json :(Callback)successCallback :(Callback)errorCallback{
@@ -337,33 +363,38 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
 }
 
 - (void) showScanner:(Callback)successCallback :(Callback)errorCallback{
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent animated:YES];
-            UIViewController *currentViewController = [[[UIApplication sharedApplication] keyWindow] rootViewController];
-            [RGLDocReader.shared showScanner:currentViewController completion:[self getCompletion]];
-        });
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent animated:YES];
+        UIViewController *currentViewController = [[[UIApplication sharedApplication] keyWindow] rootViewController];
+        [RGLDocReader.shared showScanner:currentViewController completion:[self getCompletion]];
+    });
 }
 
 - (void) recognizeImage:(NSMutableString*)base64 :(Callback)successCallback :(Callback)errorCallback{
     [self recognizeImageWith :base64 :false :successCallback :errorCallback];
 }
 
+- (void) recognizeData:(NSString*)data :(Callback)successCallback :(Callback)errorCallback{
+    [RGLDocReader.shared recognizeData :[[NSData alloc] initWithBase64EncodedString:data options:0] completion:[self getCompletion]];
+}
+
 - (void) recognizeImages:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
-        NSMutableArray<UIImage*>* images = [[NSMutableArray alloc] init];
-        for(__strong NSMutableString* base64 in input)
-            [images addObject:[UIImage imageWithData:[[NSData alloc]initWithBase64EncodedString:base64 options:NSDataBase64DecodingIgnoreUnknownCharacters]]];
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [RGLDocReader.shared recognizeImages:images completion:[self getCompletion]];
-        });
+    NSMutableArray<UIImage*>* images = [[NSMutableArray alloc] init];
+    for(__strong NSMutableString* base64 in input)
+        [images addObject:[UIImage imageWithData:[[NSData alloc]initWithBase64EncodedString:base64 options:NSDataBase64DecodingIgnoreUnknownCharacters]]];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RGLDocReader.shared recognizeImages:images completion:[self getCompletion]];
+    });
+
 }
 
 - (void) recognizeImagesWithImageInputs:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
-        NSMutableArray<RGLImageInput*>* images = [[NSMutableArray alloc] init];
-        for(__strong NSDictionary* image in input)
-            [images addObject:[RGLWJSONConstructor RGLImageInputFromJson: image]];
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [RGLDocReader.shared recognizeImagesWithImageInputs:images completion:[self getCompletion]];
-        });
+    NSMutableArray<RGLImageInput*>* images = [[NSMutableArray alloc] init];
+    for(__strong NSDictionary* image in input)
+        [images addObject:[RGLWJSONConstructor RGLImageInputFromJson: image]];
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RGLDocReader.shared recognizeImagesWithImageInputs:images completion:[self getCompletion]];
+    });
 }
 
 - (void) recognizeImageWithCameraMode:(NSMutableString*)base64 :(BOOL)cameraMode :(Callback)successCallback :(Callback)errorCallback{
@@ -371,31 +402,44 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
 }
 
 - (void) recognizeImageWith:(NSMutableString*)base64 :(BOOL)cameraMode :(Callback)successCallback :(Callback)errorCallback{
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [RGLDocReader.shared recognizeImage:[UIImage imageWithData:[[NSData alloc]initWithBase64EncodedString:base64 options:NSDataBase64DecodingIgnoreUnknownCharacters]] cameraMode:cameraMode completion:[self getCompletion]];
-        });
+    dispatch_async(dispatch_get_main_queue(), ^{
+        [RGLDocReader.shared recognizeImage:[UIImage imageWithData:[[NSData alloc]initWithBase64EncodedString:base64 options:NSDataBase64DecodingIgnoreUnknownCharacters]] cameraMode:cameraMode completion:[self getCompletion]];
+    });
 }
 
 - (void) setConfig:(NSDictionary*)config :(Callback)successCallback :(Callback)errorCallback{
-        [RegulaConfig setConfig:config :RGLDocReader.shared];
-        [self result:@"" :successCallback];
+    [RegulaConfig setConfig:config :RGLDocReader.shared];
+    [self result:@"" :successCallback];
 }
 
 - (void) getConfig:(Callback)successCallback :(Callback)errorCallback{
     [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:[RegulaConfig getConfig:RGLDocReader.shared] options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 
+- (void) checkDatabaseUpdate:(NSString*)databaseId :(Callback)successCallback :(Callback)errorCallback{
+    [RGLDocReader.shared checkDatabaseUpdate:databaseId completion:[self getCheckDatabaseUpdateCompletion: successCallback: errorCallback]];
+}
+
+- (void) getTag:(Callback)successCallback :(Callback)errorCallback{
+    [self result:[RGLDocReader.shared tag] :successCallback];
+}
+
+- (void) setTag:(NSString*)tag :(Callback)successCallback :(Callback)errorCallback{
+    [RGLDocReader.shared setTag:tag];
+    [self result:@"" :successCallback];
+}
+
 - (void) setRfidScenario:(NSDictionary*)rfidScenario :(Callback)successCallback :(Callback)errorCallback{
-        [RegulaConfig setRfidScenario:rfidScenario  :RGLDocReader.shared.rfidScenario];
-        [self result:@"" :successCallback];
+    [RegulaConfig setRfidScenario:rfidScenario  :RGLDocReader.shared.rfidScenario];
+    [self result:@"" :successCallback];
 }
 
 - (void) getRfidScenario:(Callback)successCallback :(Callback)errorCallback{
-        [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:RGLDocReader.shared.rfidScenario.rfidScenarioDictionary options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
+    [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:RGLDocReader.shared.rfidScenario.rfidScenarioDictionary options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 
 - (void) readRFID:(Callback)successCallback :(Callback)errorCallback{
-        [RGLDocReader.shared readRFID:[self getRFIDNotificationCallback] completion:[self getRFIDCompletion]];
+    [RGLDocReader.shared readRFID:[self getRFIDNotificationCallback] completion:[self getRFIDCompletion]];
 }
 
 - (void) stopRFIDReader:(Callback)successCallback :(Callback)errorCallback{
@@ -644,4 +688,10 @@ RCT_EXPORT_METHOD(exec:(NSString*)moduleName:(NSString*)action:(NSArray*)args:(R
     };
 }
 
+-(RGLDocumentReaderCheckUpdateCompletion)getCheckDatabaseUpdateCompletion:(Callback)successCallback :(Callback)errorCallback{
+    return  ^(RGLDocReaderDocumentsDatabase* database) {
+        [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocReaderDocumentsDatabase:database]] :successCallback];
+    };
+}
+
 @end

package/ios/RegulaConfig.m

@@ -305,6 +305,8 @@
             [expectedPass addObject:str];
         image.expectedPass = expectedPass;
     }
+    if([dict valueForKey:@"documentPositionIndent"] != nil)
+        image.documentPositionIndent = [dict valueForKey:@"documentPositionIndent"];
 
     return image;
 }
@@ -320,6 +322,7 @@
     result[@"colornessCheck"] = input.colornessCheck;
     result[@"moireCheck"] = input.moireCheck;
     result[@"expectedPass"] = input.expectedPass;
+    result[@"documentPositionIndent"] = input.documentPositionIndent;
 
     return result;
 }
@@ -447,6 +450,37 @@
     return group;
 }
 
++(RGLOnlineProcessingConfig*)RGLOnlineProcessingConfigFromJSON:(NSDictionary*)dict {
+    if([dict valueForKey:@"mode"] == nil) return nil;
+
+    RGLOnlineProcessingConfig *result = [[RGLOnlineProcessingConfig alloc] initWithMode:[[dict valueForKey:@"mode"] integerValue]];
+
+    if([dict valueForKey:@"imageFormat"] != nil)
+        result.imageFormat = [[dict valueForKey:@"imageFormat"] integerValue];
+    if([dict valueForKey:@"url"] != nil)
+        result.serviceURL = [dict valueForKey:@"url"];
+    if([dict valueForKey:@"imageCompressionQuality"] != nil)
+        result.imageCompressionQuality = [[dict valueForKey:@"imageCompressionQuality"] floatValue];
+    if([dict valueForKey:@"processParams"] != nil) {
+        RGLProcessParams *params = [RGLProcessParams new];
+        [self setProcessParams:[dict valueForKey:@"processParams"] :params];
+        result.processParams = params;
+    }
+
+    return result;
+}
+
++(RGLReprocParams*)RGLReprocParamsFromJSON:(NSDictionary*)dict {
+    RGLReprocParams *result = [RGLReprocParams new];
+
+    if([dict valueForKey:@"serviceUrl"] != nil)
+        result.serviceURL = [dict valueForKey:@"serviceUrl"];
+    if([dict valueForKey:@"failIfNoService"] != nil)
+        result.failIfNoService = [dict valueForKey:@"failIfNoService"];
+
+    return result;
+}
+
 +(void)setCustomization:(NSDictionary*)options :(RGLCustomization*)customization {
     if([options valueForKey:@"cameraFrameBorderWidth"] != nil)
         customization.cameraFrameBorderWidth = [[options valueForKey:@"cameraFrameBorderWidth"] floatValue];
@@ -590,12 +624,8 @@
         functionality.singleResult = [[options valueForKey:@"singleResult"] boolValue];
     if([options valueForKey:@"cameraPosition"] != nil)
         functionality.cameraPosition = [self AVCaptureDevicePositionWithNSInteger:[[options valueForKey:@"cameraPosition"] integerValue]];
-    if([options valueForKey:@"onlineMode"] != nil)
-        functionality.onlineMode = [[options valueForKey:@"onlineMode"] boolValue];
-    if([options valueForKey:@"serviceURL"] != nil)
-        functionality.serviceURL = [[options valueForKey:@"serviceURL"] stringValue];
     if([options valueForKey:@"btDeviceName"] != nil)
-        functionality.btDeviceName = [[options valueForKey:@"btDeviceName"] stringValue];
+        functionality.btDeviceName = [options valueForKey:@"btDeviceName"];
     if([options valueForKey:@"useAuthenticator"] != nil)
         functionality.useAuthenticator = [[options valueForKey:@"useAuthenticator"] boolValue];
     if([options valueForKey:@"showCaptureButtonDelayFromDetect"] != nil)
@@ -614,6 +644,8 @@
         functionality.recordScanningProcess = [[options valueForKey:@"recordScanningProcess"] boolValue];
     if([options valueForKey:@"manualMultipageMode"] != nil)
         functionality.manualMultipageMode = [[options valueForKey:@"manualMultipageMode"] boolValue];
+    if([options valueForKey:@"onlineProcessingConfiguration"] != nil)
+        functionality.onlineProcessingConfig = [self RGLOnlineProcessingConfigFromJSON:[options valueForKey:@"onlineProcessingConfiguration"]];;
 }
 
 +(void)setProcessParams:(NSDictionary*)options :(RGLProcessParams*)processParams {
@@ -713,6 +745,20 @@
         processParams.parseBarcodes = [options valueForKey:@"parseBarcodes"];
     if([options valueForKey:@"shouldReturnPackageForReprocess"] != nil)
         processParams.shouldReturnPackageForReprocess = [options valueForKey:@"shouldReturnPackageForReprocess"];
+    if([options valueForKey:@"imageOutputMaxWidth"] != nil)
+        processParams.imageOutputMaxWidth = [options valueForKey:@"imageOutputMaxWidth"];
+    if([options valueForKey:@"imageOutputMaxHeight"] != nil)
+        processParams.imageOutputMaxHeight = [options valueForKey:@"imageOutputMaxHeight"];
+    if([options valueForKey:@"disablePerforationOCR"] != nil)
+        processParams.disablePerforationOCR = [options valueForKey:@"disablePerforationOCR"];
+    if([options valueForKey:@"respectImageQuality"] != nil)
+        processParams.respectImageQuality = [options valueForKey:@"respectImageQuality"];
+    if([options valueForKey:@"splitNames"] != nil)
+        processParams.splitNames = [options valueForKey:@"splitNames"];
+    if([options valueForKey:@"processAuth"] != nil)
+        processParams.processAuth = [options valueForKey:@"processAuth"];
+    if([options valueForKey:@"documentGroupFilter"] != nil)
+        processParams.documentGroupFilter = [options mutableArrayValueForKey:@"documentGroupFilter"];
 }
 
 +(NSMutableDictionary *)getCustomization:(RGLCustomization*)customization {
@@ -797,8 +843,6 @@
     result[@"videoSessionPreset"] = [NSNumber numberWithInteger:[self NSIntegerWithAVCaptureSessionPreset:functionality.videoSessionPreset]];
     result[@"videoCaptureMotionControl"] = [NSNumber numberWithBool:functionality.videoCaptureMotionControl];
     result[@"orientation"] = [NSNumber numberWithInteger:[self NSIntegerWithUIInterfaceOrientationMask:functionality.orientation]];
-    result[@"onlineMode"] = [NSNumber numberWithBool:functionality.onlineMode];
-    result[@"serviceURL"] = functionality.serviceURL;
     result[@"cameraPosition"] = [NSNumber numberWithInteger:[self NSIntegerWithAVCaptureDevicePosition:functionality.cameraPosition]];
     result[@"btDeviceName"] = functionality.btDeviceName;
     result[@"useAuthenticator"] = [NSNumber numberWithBool:functionality.isUseAuthenticator];
@@ -866,6 +910,13 @@
     result[@"forceReadMrzBeforeLocate"] = processParams.forceReadMrzBeforeLocate;
     result[@"parseBarcodes"] = processParams.parseBarcodes;
     result[@"shouldReturnPackageForReprocess"] = processParams.shouldReturnPackageForReprocess;
+    result[@"imageOutputMaxWidth"] = processParams.imageOutputMaxWidth;
+    result[@"imageOutputMaxHeight"] = processParams.imageOutputMaxHeight;
+    result[@"disablePerforationOCR"] = processParams.disablePerforationOCR;
+    result[@"respectImageQuality"] = processParams.respectImageQuality;
+    result[@"splitNames"] = processParams.splitNames;
+    result[@"processAuth"] = processParams.processAuth;
+    result[@"documentGroupFilter"] = processParams.documentGroupFilter;
 
     return result;
 }
@@ -969,6 +1020,10 @@
         rfidScenario.authorizedInstallCert = [[options valueForKey:@"authorizedInstallCert"] boolValue];
     if([options valueForKey:@"authorizedInstallQCert"] != nil)
         rfidScenario.authorizedInstallQCert = [[options valueForKey:@"authorizedInstallQCert"] boolValue];
+    if([options valueForKey:@"reprocessParams"] != nil)
+        rfidScenario.reprocParams = [self RGLReprocParamsFromJSON: [options valueForKey:@"reprocessParams"]];
+    if([options valueForKey:@"defaultReadingBufferSize"] != nil)
+        rfidScenario.defaultReadingBufferSize = [[options valueForKey:@"defaultReadingBufferSize"] intValue];
 }
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regulaforensics/react-native-document-reader-api",
-  "version": "6.4.0",
+  "version": "6.6.0",
   "description": "React Native module for reading and validation of identification documents (API framework)",
   "main": "index.js",
   "scripts": {