@regulaforensics/cordova-plugin-document-reader-api 6.7.5 → 6.8.1

package/src/ios/{RGLDocumentReader.m → RGLWDocumentReader.m}

@@ -1,42 +1,44 @@
 @import UIKit;
-#import "RGLDocumentReader.h"
+#import "RGLWDocumentReader.h"
 @import DocumentReader;
 
-RGLRFIDCertificatesCallback paCertificateCompletion;
-RGLRFIDCertificatesCallback taCertificateCompletion;
-typedef void (^RGLRFIDSignatureCallback)(NSData *signature);
-RGLRFIDSignatureCallback taSignatureCompletion;
-RFIDDelegateNoPA* rfidDelegateNoPA;
-RGLDocumentReader* plugin;
-NSString* rfidNotificationCompletionEvent = @"rfidNotificationCompletionEvent";
-NSString* paCertificateCompletionEvent = @"paCertificateCompletionEvent";
-NSString* taCertificateCompletionEvent = @"taCertificateCompletionEvent";
-NSString* taSignatureCompletionEvent = @"taSignatureCompletionEvent";
+RGLRFIDCertificatesCallback RGLWPaCertificateCompletion;
+RGLRFIDCertificatesCallback RGLWTaCertificateCompletion;
+RGLWRFIDSignatureCallback RGLWTaSignatureCompletion;
 
-@implementation RFIDDelegateNoPA
+NSString* RGLWRfidNotificationCompletionEvent = @"rfidNotificationCompletionEvent";
+NSString* RGLWPaCertificateCompletionEvent = @"paCertificateCompletionEvent";
+NSString* RGLWTaCertificateCompletionEvent = @"taCertificateCompletionEvent";
+NSString* RGLWTaSignatureCompletionEvent = @"taSignatureCompletionEvent";
+
+RGLWRFIDDelegateNoPA* RGLWRfidDelegateNoPA;
+
+RGLWDocumentReader* RGLWPlugin;
+
+@implementation RGLWRFIDDelegateNoPA
 
 - (void)onRequestTACertificatesWithKey:(NSString *)keyCAR callback:(RGLRFIDCertificatesCallback)callback {
-    taCertificateCompletion = callback;
-    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", taCertificateCompletionEvent, keyCAR] :RGLDocumentReader.command.callbackId];
+    RGLWTaCertificateCompletion = callback;
+    [RGLWPlugin sendEvent:[NSString stringWithFormat:@"%@%@", RGLWTaCertificateCompletionEvent, keyCAR] :RGLWDocumentReader.command.callbackId];
 }
 
 - (void)onRequestTASignatureWithChallenge:(RGLTAChallenge *)challenge callback:(void(^)(NSData *signature))callback {
-    taSignatureCompletion = callback;
-    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", taSignatureCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLTAChallenge:challenge]]] :RGLDocumentReader.command.callbackId];
+    RGLWTaSignatureCompletion = callback;
+    [RGLWPlugin sendEvent:[NSString stringWithFormat:@"%@%@", RGLWTaSignatureCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLTAChallenge:challenge]]] :RGLWDocumentReader.command.callbackId];
 }
 
 - (void)didChipConnected {
-    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletion:1]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_CHIP_DETECTED = 1;
+    [RGLWPlugin sendEvent:[NSString stringWithFormat:@"%@%@", RGLWRfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletion:1]]] :RGLWDocumentReader.command.callbackId]; // int RFID_EVENT_CHIP_DETECTED = 1;
 }
 
 - (void)didReceivedError:(RGLRFIDErrorCodes)errorCode {
-    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletionWithError:2:errorCode]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_READING_ERROR = 2;
+    [RGLWPlugin sendEvent:[NSString stringWithFormat:@"%@%@", RGLWRfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletionWithError:2:errorCode]]] :RGLWDocumentReader.command.callbackId]; // int RFID_EVENT_READING_ERROR = 2;
 }
 
 @end
 
 
-@implementation RGLDocumentReader
+@implementation RGLWDocumentReader
 
 static NSNumber* _databasePercentageDownloaded;
 static CDVInvokedUrlCommand* _command;
@@ -46,9 +48,7 @@ static CDVInvokedUrlCommand* _command;
 + (CDVInvokedUrlCommand*)command { return _command; }
 + (void) setCommand:(CDVInvokedUrlCommand*)command { _command = command; }
 
-typedef void (^Callback)(NSString* response);
-
-- (void) result:(NSString*)message :(Callback)callback {
+- (void) result:(NSString*)message :(RGLWCallback)callback {
     callback(message);
 }
 
@@ -58,81 +58,85 @@ typedef void (^Callback)(NSString* response);
     [self.commandDelegate sendPluginResult:result callbackId:callbackId];
 }
 
--(void (^_Nullable)(NSProgress * _Nonnull progress))getProgressHandler:(Callback)successCallback :(Callback)errorCallback{
-    NSString* callbackId = RGLDocumentReader.command.callbackId;
+-(void (^_Nullable)(NSProgress * _Nonnull progress))getProgressHandler:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    NSString* callbackId = RGLWDocumentReader.command.callbackId;
     return ^(NSProgress * _Nonnull progress) {
-        if(RGLDocumentReader.databasePercentageDownloaded != [NSNumber numberWithDouble:progress.fractionCompleted * 100]){
+        if(RGLWDocumentReader.databasePercentageDownloaded != [NSNumber numberWithDouble:progress.fractionCompleted * 100]){
             [self sendEvent:[NSString stringWithFormat:@"%.1f", progress.fractionCompleted * 100] :callbackId];
-            [RGLDocumentReader setDatabasePercentageDownloaded:[NSNumber numberWithDouble:progress.fractionCompleted * 100]];
+            [RGLWDocumentReader setDatabasePercentageDownloaded:[NSNumber numberWithDouble:progress.fractionCompleted * 100]];
         }
     };
 }
 
 -(RGLDocumentReaderCompletion _Nonnull)getCompletion {
-    NSString* callbackId = RGLDocumentReader.command.callbackId;
+    NSString* callbackId = RGLWDocumentReader.command.callbackId;
     return ^(RGLDocReaderAction action, RGLDocumentReaderResults * _Nullable results, NSError * _Nullable error) {
         [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateCompletion:[RGLWJSONConstructor generateDocReaderAction: action] :results :error :nil]] :callbackId];
     };
 }
 
 -(RGLRFIDProcessCompletion _Nonnull)getRFIDCompletion {
-    NSString* callbackId = RGLDocumentReader.command.callbackId;
+    NSString* callbackId = RGLWDocumentReader.command.callbackId;
     return ^(RGLRFIDCompleteAction action, RGLDocumentReaderResults * _Nullable results, NSError * _Nullable error, RGLRFIDErrorCodes errorCode) {
         [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateCompletion:[RGLWJSONConstructor generateRFIDCompleteAction: action] :results :error :nil]] :callbackId];
     };
 }
 
 -(RGLRFIDNotificationCallback _Nonnull)getRFIDNotificationCallback {
-    NSString* callbackId = RGLDocumentReader.command.callbackId;
+    NSString* callbackId = RGLWDocumentReader.command.callbackId;
     return ^(RGLRFIDNotificationAction notificationAction, RGLRFIDNotify* _Nullable notify) {
         [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateCompletion:[RGLWJSONConstructor generateRFIDNotificationAction:notificationAction] :nil :nil :notify]] :callbackId];
     };
 }
 
 - (void)didFinishRecordingToFile:(NSURL *)fileURL {
-    NSString* callbackId = RGLDocumentReader.command.callbackId;
+    NSString* callbackId = RGLWDocumentReader.command.callbackId;
     [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateVideoEncoderCompletion:fileURL :nil]] :callbackId];
 }
 
 - (void)didFailWithError:(NSError *)error {
-    NSString* callbackId = RGLDocumentReader.command.callbackId;
+    NSString* callbackId = RGLWDocumentReader.command.callbackId;
     [self sendEvent:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateVideoEncoderCompletion:nil :error]] :callbackId];
 }
 
 - (void)onRequestPACertificatesWithSerial:(NSData *)serialNumber issuer:(RGLPAResourcesIssuer *)issuer callback:(RGLRFIDCertificatesCallback)callback {
-    paCertificateCompletion = callback;
-    [self sendEvent:[NSString stringWithFormat:@"%@%@", paCertificateCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generatePACertificateCompletion:serialNumber :issuer]]] :RGLDocumentReader.command.callbackId];
+    RGLWPaCertificateCompletion = callback;
+    [self sendEvent:[NSString stringWithFormat:@"%@%@", RGLWPaCertificateCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generatePACertificateCompletion:serialNumber :issuer]]] :RGLWDocumentReader.command.callbackId];
 }
 
 - (void)onRequestTACertificatesWithKey:(NSString *)keyCAR callback:(RGLRFIDCertificatesCallback)callback {
-    taCertificateCompletion = callback;
-    [self sendEvent:[NSString stringWithFormat:@"%@%@", taCertificateCompletionEvent, keyCAR] :RGLDocumentReader.command.callbackId];
+    RGLWTaCertificateCompletion = callback;
+    [self sendEvent:[NSString stringWithFormat:@"%@%@", RGLWTaCertificateCompletionEvent, keyCAR] :RGLWDocumentReader.command.callbackId];
 }
 
 - (void)onRequestTASignatureWithChallenge:(RGLTAChallenge *)challenge callback:(void(^)(NSData *signature))callback {
-    taSignatureCompletion = callback;
-    [self sendEvent:[NSString stringWithFormat:@"%@%@", taSignatureCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLTAChallenge:challenge]]] :RGLDocumentReader.command.callbackId];
+    RGLWTaSignatureCompletion = callback;
+    [self sendEvent:[NSString stringWithFormat:@"%@%@", RGLWTaSignatureCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLTAChallenge:challenge]]] :RGLWDocumentReader.command.callbackId];
 }
 
 - (void)didChipConnected {
-    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletion:1]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_CHIP_DETECTED = 1;
+    [RGLWPlugin sendEvent:[NSString stringWithFormat:@"%@%@", RGLWRfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletion:1]]] :RGLWDocumentReader.command.callbackId]; // int RFID_EVENT_CHIP_DETECTED = 1;
 }
 
 - (void)didReceivedError:(RGLRFIDErrorCodes)errorCode {
-    [plugin sendEvent:[NSString stringWithFormat:@"%@%@", rfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletionWithError:2:errorCode]]] :RGLDocumentReader.command.callbackId]; // int RFID_EVENT_READING_ERROR = 2;
+    [RGLWPlugin sendEvent:[NSString stringWithFormat:@"%@%@", RGLWRfidNotificationCompletionEvent, [RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRfidNotificationCompletionWithError:2:errorCode]]] :RGLWDocumentReader.command.callbackId]; // int RFID_EVENT_READING_ERROR = 2;
+}
+
+- (void)onCustomButtonTappedWithTag:(NSInteger)tag {
+    [self sendEvent:[NSString stringWithFormat:@"%ld", tag] :RGLWDocumentReader.command.callbackId];
 }
 
 - (void) exec:(CDVInvokedUrlCommand*)command {
-    [RGLDocumentReader setCommand:command];
-    plugin = self;
+    [RGLWDocumentReader setCommand:command];
+    RGLWPlugin = self;
     NSMutableArray* args = [[NSMutableArray alloc] init];
     NSString* action = [[command arguments] objectAtIndex:0];
     for(int i = 1;i<[command arguments].count;i++)
         [args addObject:[[command arguments] objectAtIndex:i]];
-    Callback successCallback = ^(NSString* response){
+    RGLWCallback successCallback = ^(NSString* response){
         [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:response] callbackId:command.callbackId];
     };
-    Callback errorCallback = ^(NSString* response){
+    RGLWCallback errorCallback = ^(NSString* response){
         [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:response] callbackId:command.callbackId];
     };
 
@@ -272,6 +276,10 @@ typedef void (^Callback)(NSString* response);
         [self recognizeImageWithCameraMode :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
     else if([action isEqualToString:@"recognizeImagesWithImageInputs"])
         [self recognizeImagesWithImageInputs :[args objectAtIndex:0] :successCallback :errorCallback];
+    else if([action isEqualToString:@"setOnCustomButtonTappedListener"])
+        [self setOnCustomButtonTappedListener :successCallback :errorCallback];
+    else if([action isEqualToString:@"setLanguage"])
+        [self setLanguage :[args objectAtIndex:0] :successCallback :errorCallback];
     else if([action isEqualToString:@"textFieldValueByType"])
         [self textFieldValueByType :[args objectAtIndex:0] :[args objectAtIndex:1] :successCallback :errorCallback];
     else if([action isEqualToString:@"textFieldValueByTypeLcid"])
@@ -310,80 +318,95 @@ typedef void (^Callback)(NSString* response);
         [self result:[NSString stringWithFormat:@"%@/%@", @"method not implemented: ", action] :errorCallback];
 }
 
-- (void) initializeReaderAutomatically:(Callback)successCallback :(Callback)errorCallback{
+- (void) initializeReaderAutomatically:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     NSString *dataPath = [[NSBundle mainBundle] pathForResource:@"regula.license" ofType:nil];
     NSData *licenseData = [NSData dataWithContentsOfFile:dataPath];
     [RGLDocReader.shared initializeReaderWithConfig:[RGLConfig configWithLicenseData:licenseData] completion:[self getInitCompletion :successCallback :errorCallback]];
 }
 
-- (void) isBlePermissionsGranted:(Callback)successCallback :(Callback)errorCallback{
+- (void) isBlePermissionsGranted:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"isBlePermissionsGranted() is an android-only method" :errorCallback];
 }
 
-- (void) startBluetoothService:(Callback)successCallback :(Callback)errorCallback{
+- (void) startBluetoothService:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"startBluetoothService() is an android-only method" :errorCallback];
 }
 
-- (void) initializeReaderBleDeviceConfig:(Callback)successCallback :(Callback)errorCallback{
+- (void) initializeReaderBleDeviceConfig:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"initializeReaderBleDeviceConfig() is an android-only method" :errorCallback];
 }
 
-- (void) resetConfiguration:(Callback)successCallback :(Callback)errorCallback{
+- (void) resetConfiguration:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocReader.shared.functionality = [RGLFunctionality new];
     RGLDocReader.shared.processParams = [RGLProcessParams new];
     RGLDocReader.shared.customization = [RGLCustomization new];
     successCallback(@"");
 }
 
-- (void) setEnableCoreLogs:(BOOL)logs :(Callback)successCallback :(Callback)errorCallback{
+- (void) setEnableCoreLogs:(BOOL)logs :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"setEnableCoreLogs() is an android-only method" :errorCallback];
 }
 
-- (void) showScannerWithCameraID:(NSNumber*)cameraID :(Callback)successCallback :(Callback)errorCallback{
+- (void) showScannerWithCameraID:(NSNumber*)cameraID :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"showScannerWithCameraID() is an android-only method" :errorCallback];
 }
 
-- (void) stopRFIDReaderWithErrorMessage:(NSMutableString*)message :(Callback)successCallback :(Callback)errorCallback{
+- (void) stopRFIDReaderWithErrorMessage:(NSMutableString*)message :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared stopRFIDReaderWithErrorMessage:message completion:^() {
         [self result:@"" :successCallback];
     }];
 }
 
-- (void) recognizeImageWithOpts:(NSString*)base64 :(NSDictionary*)opts :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeImageWithOpts:(NSString*)base64 :(NSDictionary*)opts :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"recognizeImageWithOpts() is an android-only method" :errorCallback];
 }
 
-- (void) recognizeVideoFrame:(NSString*)byteString :(NSDictionary*)opts :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeVideoFrame:(NSString*)byteString :(NSDictionary*)opts :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"recognizeVideoFrame() is an android-only method" :errorCallback];
 }
 
-- (void) showScannerWithCameraIDAndOpts:(NSNumber*)cameraID :(NSDictionary*)opts :(Callback)successCallback :(Callback)errorCallback{
+- (void) showScannerWithCameraIDAndOpts:(NSNumber*)cameraID :(NSDictionary*)opts :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"showScannerWithCameraIDAndOpts() is an android-only method" :errorCallback];
 }
 
-- (void) getLicenseMessage:(Callback)successCallback :(Callback)errorCallback{
+- (void) getLicenseMessage:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:@"getLicenseMessage() is an android-only method" :successCallback];
 }
 
-- (void) initializeReader:(NSDictionary*)config :(Callback)successCallback :(Callback)errorCallback{
+- (void) setOnCustomButtonTappedListener:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    RGLDocReader.shared.customization.actionDelegate = self;
+    [self result:@"" :successCallback];
+}
+
+- (void) setLanguage:(NSString*)language :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    RGLDocReader.shared.localizationHandler = ^NSString * _Nullable(NSString * _Nonnull localizationKey) {
+        NSString *result = NSLocalizedStringFromTable(localizationKey, language, @"");
+        if (![result isEqualToString:localizationKey])
+            return result;
+        return nil;
+    };
+    [self result:@"" :successCallback];
+}
+
+- (void) initializeReader:(NSDictionary*)config :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared initializeReaderWithConfig:[RGLWJSONConstructor RGLConfigFromJson:config] completion:[self getInitCompletion :successCallback :errorCallback]];
 }
 
-- (void) parseCoreResults:(NSString*)json :(Callback)successCallback :(Callback)errorCallback{
+- (void) parseCoreResults:(NSString*)json :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderResults:[RGLDocumentReaderResults initWithRawString: json]]] :successCallback];
 }
 
-- (void) startRFIDReader:(Callback)successCallback :(Callback)errorCallback{
+- (void) startRFIDReader:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     dispatch_async(dispatch_get_main_queue(), ^{
         [RGLDocReader.shared startRFIDReaderFromPresenter:[[[UIApplication sharedApplication] keyWindow] rootViewController] completion:[self getCompletion]];
     });
 }
 
-- (void) prepareDatabase:(NSString*)dbID :(Callback)successCallback :(Callback)errorCallback{
+- (void) prepareDatabase:(NSString*)dbID :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared prepareDatabase:dbID progressHandler:[self getProgressHandler :successCallback :errorCallback] completion:[self getPrepareCompletion :successCallback :errorCallback]];
 }
 
-- (void) removeDatabase:(Callback)successCallback :(Callback)errorCallback{
+- (void) removeDatabase:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared removeDatabase:^(BOOL successful, NSError * _Nullable error) {
         if (successful)
             [self result:@"database removed" :successCallback];
@@ -392,32 +415,34 @@ typedef void (^Callback)(NSString* response);
     }];
 }
 
-- (void) cancelDBUpdate:(Callback)successCallback :(Callback)errorCallback{
+- (void) cancelDBUpdate:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared cancelDBUpdate];
     [self result:@"" :successCallback];
 }
 
--(void) runAutoUpdate:(NSString*)dbID :(Callback)successCallback :(Callback)errorCallback{
+-(void) runAutoUpdate:(NSString*)dbID :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared runAutoUpdate:dbID progressHandler:[self getProgressHandler :successCallback :errorCallback] completion:[self getPrepareCompletion :successCallback :errorCallback]];
 }
 
-- (void) showScanner:(Callback)successCallback :(Callback)errorCallback{
+- (void) showScanner:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     dispatch_async(dispatch_get_main_queue(), ^{
+        #pragma clang diagnostic ignored "-Wdeprecated-declarations"
         [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent animated:YES];
+        #pragma clang diagnostic pop
         UIViewController *currentViewController = [[[UIApplication sharedApplication] keyWindow] rootViewController];
         [RGLDocReader.shared showScanner:currentViewController completion:[self getCompletion]];
     });
 }
 
-- (void) recognizeImage:(NSMutableString*)base64 :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeImage:(NSMutableString*)base64 :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self recognizeImageWith :base64 :false :successCallback :errorCallback];
 }
 
-- (void) recognizeData:(NSString*)data :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeData:(NSString*)data :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared recognizeData :[[NSData alloc] initWithBase64EncodedString:data options:0] completion:[self getCompletion]];
 }
 
-- (void) recognizeImages:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeImages:(NSArray*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     NSMutableArray<UIImage*>* images = [[NSMutableArray alloc] init];
     for(__strong NSMutableString* base64 in input)
         [images addObject:[UIImage imageWithData:[[NSData alloc]initWithBase64EncodedString:base64 options:NSDataBase64DecodingIgnoreUnknownCharacters]]];
@@ -427,7 +452,7 @@ typedef void (^Callback)(NSString* response);
 
 }
 
-- (void) recognizeImagesWithImageInputs:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeImagesWithImageInputs:(NSArray*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     NSMutableArray<RGLImageInput*>* images = [[NSMutableArray alloc] init];
     for(__strong NSDictionary* image in input)
         [images addObject:[RGLWJSONConstructor RGLImageInputFromJson: image]];
@@ -436,61 +461,61 @@ typedef void (^Callback)(NSString* response);
     });
 }
 
-- (void) recognizeImageWithCameraMode:(NSMutableString*)base64 :(BOOL)cameraMode :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeImageWithCameraMode:(NSMutableString*)base64 :(BOOL)cameraMode :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self recognizeImageWith :base64 :cameraMode :successCallback :errorCallback];
 }
 
-- (void) recognizeImageWith:(NSMutableString*)base64 :(BOOL)cameraMode :(Callback)successCallback :(Callback)errorCallback{
+- (void) recognizeImageWith:(NSMutableString*)base64 :(BOOL)cameraMode :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     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];
+- (void) setConfig:(NSDictionary*)config :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    [RGLWRegulaConfig 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) getConfig:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:[RGLWRegulaConfig getConfig:RGLDocReader.shared] options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 
-- (void) checkDatabaseUpdate:(NSString*)databaseId :(Callback)successCallback :(Callback)errorCallback{
+- (void) checkDatabaseUpdate:(NSString*)databaseId :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared checkDatabaseUpdate:databaseId completion:[self getCheckDatabaseUpdateCompletion: successCallback: errorCallback]];
 }
 
-- (void) getTag:(Callback)successCallback :(Callback)errorCallback{
+- (void) getTag:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[RGLDocReader.shared tag] :successCallback];
 }
 
-- (void) setTag:(NSString*)tag :(Callback)successCallback :(Callback)errorCallback{
+- (void) setTag:(NSString*)tag :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared setTag:tag];
     [self result:@"" :successCallback];
 }
 
-- (void) setRfidScenario:(NSDictionary*)rfidScenario :(Callback)successCallback :(Callback)errorCallback{
-    [RegulaConfig setRfidScenario:rfidScenario  :RGLDocReader.shared.rfidScenario];
+- (void) setRfidScenario:(NSDictionary*)rfidScenario :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    [RGLWRegulaConfig setRfidScenario:rfidScenario  :RGLDocReader.shared.rfidScenario];
     [self result:@"" :successCallback];
 }
 
-- (void) getRfidScenario:(Callback)successCallback :(Callback)errorCallback{
+- (void) getRfidScenario:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:RGLDocReader.shared.rfidScenario.rfidScenarioDictionary options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 
-- (void) readRFID:(Callback)successCallback :(Callback)errorCallback{
+- (void) readRFID:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared readRFID:[self getRFIDNotificationCallback] completion:[self getRFIDCompletion]];
 }
 
-- (void) stopRFIDReader:(Callback)successCallback :(Callback)errorCallback{
+- (void) stopRFIDReader:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared stopRFIDReader:^(){[self result:@"" :successCallback];}];
 }
 
-- (void) clearPKDCertificates:(Callback)successCallback :(Callback)errorCallback{
+- (void) clearPKDCertificates:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared clearPKDCertificates];
     [self result:@"" :successCallback];
 }
 
-- (void) addPKDCertificates:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
+- (void) addPKDCertificates:(NSArray*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     NSMutableArray *certificates = [[NSMutableArray alloc] init];
     for(NSDictionary* certificateJSON in input)
         [certificates addObject:[RGLWJSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
@@ -498,16 +523,16 @@ typedef void (^Callback)(NSString* response);
     [self result:@"" :successCallback];
 }
 
-- (void) deinitializeReader:(Callback)successCallback :(Callback)errorCallback{
+- (void) deinitializeReader:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared deinitializeReader];
     [self result:@"" :successCallback];
 }
 
-- (void) selectedScenario:(Callback)successCallback :(Callback)errorCallback{
+- (void) selectedScenario:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLScenario:RGLDocReader.shared.selectedScenario]] :successCallback];
 }
 
-- (void) stopScanner:(Callback)successCallback :(Callback)errorCallback{
+- (void) stopScanner:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     dispatch_async(dispatch_get_main_queue(), ^{
         [RGLDocReader.shared stopScanner:^(){
             [self result:@"" :successCallback];
@@ -515,57 +540,57 @@ typedef void (^Callback)(NSString* response);
     });
 }
 
-- (void) startNewSession:(Callback)successCallback :(Callback)errorCallback{
+- (void) startNewSession:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared startNewSession];
     [self result:@"" :successCallback];
 }
 
-- (void) startNewPage:(Callback)successCallback :(Callback)errorCallback{
+- (void) startNewPage:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared startNewPage];
     [self result:@"" :successCallback];
 }
 
-- (void) getDocumentReaderIsReady:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDocumentReaderIsReady:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[RGLDocReader.shared isDocumentReaderIsReady] ? @YES : @NO :successCallback];
 }
 
-- (void) getAPIVersion:(Callback)successCallback :(Callback)errorCallback{
+- (void) getAPIVersion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.api :successCallback];
 }
 
-- (void) getCoreVersion:(Callback)successCallback :(Callback)errorCallback{
+- (void) getCoreVersion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.core :successCallback];
 }
 
-- (void) getCoreMode:(Callback)successCallback :(Callback)errorCallback{
+- (void) getCoreMode:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.coreMode :successCallback];
 }
 
-- (void) getDatabaseID:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDatabaseID:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.database.databaseID :successCallback];
 }
 
-- (void) getDatabaseVersion:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDatabaseVersion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.database.version :successCallback];
 }
 
-- (void) getDatabaseDate:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDatabaseDate:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.database.date :successCallback];
 }
 
-- (void) getDatabaseDescription:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDatabaseDescription:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.version.database.databaseDescription :successCallback];
 }
 
-- (void) getDatabaseCountriesNumber:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDatabaseCountriesNumber:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[NSNumber numberWithInteger:RGLDocReader.shared.version.database.countriesNumber] :successCallback];
 }
 
-- (void) getDatabaseDocumentsNumber:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDatabaseDocumentsNumber:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:[NSNumber numberWithInteger:RGLDocReader.shared.version.database.documentsNumber] :successCallback];
 }
 
-- (void) getLicenseExpiryDate:(Callback)successCallback :(Callback)errorCallback{
+- (void) getLicenseExpiryDate:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
     [formatter setFormatterBehavior:NSDateFormatterBehaviorDefault];
     [formatter setDateStyle:NSDateFormatterShortStyle];
@@ -573,60 +598,60 @@ typedef void (^Callback)(NSString* response);
     [self result:[formatter stringFromDate:RGLDocReader.shared.license.expiryDate] :successCallback];
 }
 
-- (void) getLicenseCountryFilter:(Callback)successCallback :(Callback)errorCallback{
+- (void) getLicenseCountryFilter:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     if(RGLDocReader.shared.license.countryFilter == nil)
         [self result:@"nil" :successCallback];
     else
         [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:RGLDocReader.shared.license.countryFilter options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 
-- (void) licenseIsRfidAvailable:(Callback)successCallback :(Callback)errorCallback{
+- (void) licenseIsRfidAvailable:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.license.isRfidAvailable ? @YES : @NO :successCallback];
 }
 
-- (void) getDocumentReaderStatus:(Callback)successCallback :(Callback)errorCallback{
+- (void) getDocumentReaderStatus:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.documentReaderStatus :successCallback];
 }
 
-- (void) setTCCParams:(NSDictionary*)params :(Callback)successCallback :(Callback)errorCallback{
+- (void) setTCCParams:(NSDictionary*)params :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [RGLDocReader.shared setTCCParams:[RGLWJSONConstructor RGLTCCParamsFromJson:params] completion:[self getTCCParamsCompletion:successCallback :errorCallback]];
 }
 
-- (void) getRfidSessionStatus:(Callback)successCallback :(Callback)errorCallback{
+- (void) getRfidSessionStatus:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.rfidSessionStatus :successCallback];
 }
 
-- (void) setRfidSessionStatus:(NSString*)status :(Callback)successCallback :(Callback)errorCallback{
+- (void) setRfidSessionStatus:(NSString*)status :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocReader.shared.rfidSessionStatus = status;
     [self result:@"" :successCallback];
 }
 
-- (void) getCurrentScenario:(Callback)successCallback :(Callback)errorCallback{
+- (void) getCurrentScenario:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.processParams.scenario :successCallback];
 }
 
-- (void) getCameraSessionIsPaused:(Callback)successCallback :(Callback)errorCallback{
+- (void) getCameraSessionIsPaused:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.isCameraSessionIsPaused ? @YES : @NO :successCallback];
 }
 
-- (void) setCameraSessionIsPaused:(BOOL)paused :(Callback)successCallback :(Callback)errorCallback{
+- (void) setCameraSessionIsPaused:(BOOL)paused :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocReader.shared.cameraSessionIsPaused = paused;
     [self result:@"" :successCallback];
 }
 
-- (void) isRFIDAvailableForUse:(Callback)successCallback :(Callback)errorCallback{
+- (void) isRFIDAvailableForUse:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.isRFIDAvailableForUse ? @YES : @NO :successCallback];
 }
 
-- (void) isAuthenticatorAvailableForUse:(Callback)successCallback :(Callback)errorCallback{
+- (void) isAuthenticatorAvailableForUse:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.isAuthenticatorAvailableForUse ? @YES : @NO :successCallback];
 }
 
-- (void) getSessionLogFolder:(Callback)successCallback :(Callback)errorCallback{
+- (void) getSessionLogFolder:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     [self result:RGLDocReader.shared.processParams.sessionLogFolder :successCallback];
 }
 
-- (void) getScenario:(NSString*)scenarioID :(Callback)successCallback :(Callback)errorCallback{
+- (void) getScenario:(NSString*)scenarioID :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     BOOL success = false;
     for(RGLScenario *scenario in RGLDocReader.shared.availableScenarios)
         if([scenario.identifier isEqualToString:scenarioID]){
@@ -638,48 +663,48 @@ typedef void (^Callback)(NSString* response);
         [self result:@"Scenario unavailable" :errorCallback];
 }
 
-- (void) providePACertificates:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
-    if(paCertificateCompletion == nil){
+- (void) providePACertificates:(NSArray*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    if(RGLWPaCertificateCompletion == nil){
         [self result:@"paCertificateCompletion is nil" :errorCallback];
         return;
     }
     NSMutableArray *certificates = [[NSMutableArray alloc] init];
     for(NSDictionary* certificateJSON in input)
         [certificates addObject:[RGLWJSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
-    paCertificateCompletion(certificates);
+    RGLWPaCertificateCompletion(certificates);
     [self result:@"" :successCallback];
 }
 
-- (void) provideTACertificates:(NSArray*)input :(Callback)successCallback :(Callback)errorCallback{
-    if(taCertificateCompletion == nil){
+- (void) provideTACertificates:(NSArray*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    if(RGLWTaCertificateCompletion == nil){
         [self result:@"taCertificateCompletion is nil" :errorCallback];
         return;
     }
     NSMutableArray *certificates = [[NSMutableArray alloc] init];
     for(NSDictionary* certificateJSON in input)
         [certificates addObject:[RGLWJSONConstructor RGLPKDCertificateFromJson:certificateJSON]];
-    taCertificateCompletion(certificates);
+    RGLWTaCertificateCompletion(certificates);
     [self result:@"" :successCallback];
 }
 
-- (void) provideTASignature:(NSString*)input :(Callback)successCallback :(Callback)errorCallback{
-    if(taSignatureCompletion == nil){
+- (void) provideTASignature:(NSString*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
+    if(RGLWTaSignatureCompletion == nil){
         [self result:@"taSignatureCompletion is nil" :errorCallback];
         return;
     }
-    taSignatureCompletion([[NSData alloc] initWithBase64EncodedString:input options:0]);
+    RGLWTaSignatureCompletion([[NSData alloc] initWithBase64EncodedString:input options:0]);
     [self result:@"" :successCallback];
 }
 
-- (void) setRfidDelegate:(NSNumber*)input :(Callback)successCallback :(Callback)errorCallback{
+- (void) setRfidDelegate:(NSNumber*)input :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     switch([input integerValue]){
         case 0:
             [RGLDocReader shared].rfidDelegate = nil;
             break;
         case 1:
-            if(rfidDelegateNoPA == nil)
-                rfidDelegateNoPA = [RFIDDelegateNoPA new];
-            [RGLDocReader shared].rfidDelegate = rfidDelegateNoPA;
+            if(RGLWRfidDelegateNoPA == nil)
+                RGLWRfidDelegateNoPA = [RGLWRFIDDelegateNoPA new];
+            [RGLDocReader shared].rfidDelegate = RGLWRfidDelegateNoPA;
             break;
         case 2:
             [RGLDocReader shared].rfidDelegate = self;
@@ -692,44 +717,44 @@ typedef void (^Callback)(NSString* response);
     [self result:@"" :successCallback];
 }
 
-- (void) getAvailableScenarios:(Callback)successCallback :(Callback)errorCallback{
+- (void) getAvailableScenarios:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     NSMutableArray *availableScenarios = [[NSMutableArray alloc] init];
     for(RGLScenario *scenario in RGLDocReader.shared.availableScenarios)
         [availableScenarios addObject:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLScenario:scenario]]];
     [self result:[[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:availableScenarios options:NSJSONWritingPrettyPrinted error:nil] encoding:NSUTF8StringEncoding] :successCallback];
 }
 
-- (void) textFieldValueByType:(NSString*)rawResult :(NSNumber*)fieldType :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldValueByType:(NSString*)rawResult :(NSNumber*)fieldType :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getTextFieldValueByType:[fieldType integerValue]] :successCallback];
 }
 
-- (void) textFieldValueByTypeLcid:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldValueByTypeLcid:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getTextFieldValueByType:[fieldType integerValue] lcid:[lcid integerValue]] :successCallback];
 }
 
-- (void) textFieldValueByTypeSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldValueByTypeSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getTextFieldValueByType:[fieldType integerValue] source:[source integerValue]] :successCallback];
 }
 
-- (void) textFieldValueByTypeLcidSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(NSNumber*)source :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldValueByTypeLcidSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(NSNumber*)source :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getTextFieldValueByType:[fieldType integerValue] lcid:[lcid integerValue] source:[source integerValue]] :successCallback];
 }
 
-- (void) textFieldValueByTypeSourceOriginal:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(BOOL)original :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldValueByTypeSourceOriginal:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(BOOL)original :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getTextFieldValueByType:[fieldType integerValue] source:[source integerValue] original:original] :successCallback];
 }
 
-- (void) textFieldValueByTypeLcidSourceOriginal:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(NSNumber*)source :(BOOL)original :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldValueByTypeLcidSourceOriginal:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(NSNumber*)source :(BOOL)original :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getTextFieldValueByType:[fieldType integerValue] lcid:[lcid integerValue] source:[source integerValue] original:original] :successCallback];
 }
 
-- (void) textFieldByType:(NSString*)rawResult :(NSNumber*)fieldType :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldByType:(NSString*)rawResult :(NSNumber*)fieldType :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     RGLDocumentReaderTextField* result = [results getTextFieldByType:[fieldType integerValue]];
     if(result == nil)
@@ -737,7 +762,7 @@ typedef void (^Callback)(NSString* response);
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderTextField:result]] :successCallback];
 }
 
-- (void) textFieldByTypeLcid:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(Callback)successCallback :(Callback)errorCallback{
+- (void) textFieldByTypeLcid:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)lcid :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     RGLDocumentReaderTextField* result = [results getTextFieldByType:[fieldType integerValue] lcid:[lcid integerValue]];
     if(result == nil)
@@ -745,7 +770,7 @@ typedef void (^Callback)(NSString* response);
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderTextField:result]] :successCallback];
 }
 
-- (void) graphicFieldByTypeSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldByTypeSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     RGLDocumentReaderGraphicField* result = [results getGraphicFieldByType:[fieldType integerValue] source:[source integerValue]];
     if(result == nil)
@@ -753,7 +778,7 @@ typedef void (^Callback)(NSString* response);
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderGraphicField:result]] :successCallback];
 }
 
-- (void) graphicFieldByTypeSourcePageIndex:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldByTypeSourcePageIndex:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     RGLDocumentReaderGraphicField* result = [results getGraphicFieldByType:[fieldType integerValue] source:[source integerValue] pageIndex:[pageIndex integerValue]];
     if(result == nil)
@@ -761,7 +786,7 @@ typedef void (^Callback)(NSString* response);
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderGraphicField:result]] :successCallback];
 }
 
-- (void) graphicFieldByTypeSourcePageIndexLight:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(NSNumber*)light :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldByTypeSourcePageIndexLight:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(NSNumber*)light :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     RGLDocumentReaderGraphicField* result = [results getGraphicFieldByType:[fieldType integerValue] source:[source integerValue] pageIndex:[pageIndex integerValue] light:[light integerValue]];
     if(result == nil)
@@ -769,37 +794,37 @@ typedef void (^Callback)(NSString* response);
     [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocumentReaderGraphicField:result]] :successCallback];
 }
 
-- (void) graphicFieldImageByType:(NSString*)rawResult :(NSNumber*)fieldType :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldImageByType:(NSString*)rawResult :(NSNumber*)fieldType :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[UIImageJPEGRepresentation([results getGraphicFieldImageByType:[fieldType integerValue]], 1.0) base64EncodedStringWithOptions:0] :successCallback];
 }
 
-- (void) graphicFieldImageByTypeSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldImageByTypeSource:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[UIImageJPEGRepresentation([results getGraphicFieldImageByType:[fieldType integerValue] source:[source integerValue]], 1.0) base64EncodedStringWithOptions:0] :successCallback];
 }
 
-- (void) graphicFieldImageByTypeSourcePageIndex:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldImageByTypeSourcePageIndex:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[UIImageJPEGRepresentation([results getGraphicFieldImageByType:[fieldType integerValue] source:[source integerValue] pageIndex:[pageIndex integerValue]], 1.0) base64EncodedStringWithOptions:0] :successCallback];
 }
 
-- (void) graphicFieldImageByTypeSourcePageIndexLight:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(NSNumber*)light :(Callback)successCallback :(Callback)errorCallback{
+- (void) graphicFieldImageByTypeSourcePageIndexLight:(NSString*)rawResult :(NSNumber*)fieldType :(NSNumber*)source :(NSNumber*)pageIndex :(NSNumber*)light :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[UIImageJPEGRepresentation([results getGraphicFieldImageByType:[fieldType integerValue] source:[source integerValue] pageIndex:[pageIndex integerValue] light:[light integerValue]], 1.0) base64EncodedStringWithOptions:0] :successCallback];
 }
 
-- (void) containers:(NSString*)rawResult :(NSArray<NSNumber*>*)resultType :(Callback)successCallback :(Callback)errorCallback{
+- (void) containers:(NSString*)rawResult :(NSArray<NSNumber*>*)resultType :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getContainersByResultTypes:resultType] :successCallback];
 }
 
-- (void) encryptedContainers:(NSString*)rawResult :(Callback)successCallback :(Callback)errorCallback{
+- (void) encryptedContainers:(NSString*)rawResult :(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     RGLDocumentReaderResults* results = [RGLDocumentReaderResults initWithRawString:rawResult];
     [self result:[results getEncryptedContainers] :successCallback];
 }
 
--(RGLDocumentReaderInitializationCompletion)getInitCompletion:(Callback)successCallback :(Callback)errorCallback{
+-(RGLDocumentReaderInitializationCompletion)getInitCompletion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     return ^(BOOL successful, NSError * _Nullable error ) {
         if (successful){
             [RGLDocReader shared].functionality.recordScanningProcessDelegate = self;
@@ -809,7 +834,7 @@ typedef void (^Callback)(NSString* response);
     };
 }
 
--(RGLDocumentReaderPrepareCompletion _Nonnull)getPrepareCompletion:(Callback)successCallback :(Callback)errorCallback{
+-(RGLDocumentReaderPrepareCompletion _Nonnull)getPrepareCompletion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     return ^(BOOL successful, NSError * _Nullable error) {
         if (successful)
             [self result:@"database prepared" :successCallback];
@@ -818,7 +843,7 @@ typedef void (^Callback)(NSString* response);
     };
 }
 
--(void (^_Nullable)(BOOL success, NSError * _Nullable error))getTCCParamsCompletion:(Callback)successCallback :(Callback)errorCallback{
+-(void (^_Nullable)(BOOL success, NSError * _Nullable error))getTCCParamsCompletion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     return  ^(BOOL success, NSError * _Nullable error) {
         if (success)
             [self result:@"success" :successCallback];
@@ -827,7 +852,7 @@ typedef void (^Callback)(NSString* response);
     };
 }
 
--(RGLDocumentReaderCheckUpdateCompletion)getCheckDatabaseUpdateCompletion:(Callback)successCallback :(Callback)errorCallback{
+-(RGLDocumentReaderCheckUpdateCompletion)getCheckDatabaseUpdateCompletion:(RGLWCallback)successCallback :(RGLWCallback)errorCallback{
     return  ^(RGLDocReaderDocumentsDatabase* database) {
         [self result:[RGLWJSONConstructor dictToString:[RGLWJSONConstructor generateRGLDocReaderDocumentsDatabase:database]] :successCallback];
     };