@regulaforensics/face-sdk 8.2.855-nightly → 8.2.856-rc

package/examples/react_native/package.json

@@ -8,8 +8,8 @@
     "start": "expo start"
   },
   "dependencies": {
-    "@regulaforensics/face-sdk": "8.2.855-nightly",
-    "@regulaforensics/face-core-basic": "8.2.453-nightly",
+    "@regulaforensics/face-sdk": "8.2.856-rc",
+    "@regulaforensics/face-core-basic": "8.2.454-rc",
     "react-native": "^0.81.4",
     "react-native-fs": "^2.20.0",
     "react-native-image-picker": "^8.2.1",

package/ios/CVDFaceSDK.h

@@ -0,0 +1,7 @@
+#import <Cordova/CDVPlugin.h>
+#import <Foundation/Foundation.h>
+#import "RFSWMain.h"
+@import UIKit;
+
+@interface CVDFaceSDK : CDVPlugin
+@end

package/ios/CVDFaceSDK.m

@@ -0,0 +1,43 @@
+#import "CVDFaceSDK.h"
+
+@implementation CVDFaceSDK
+
+static NSMutableDictionary<NSString*, NSString*>* _eventCallbackIds = nil;
+- (NSMutableDictionary<NSString*, NSString*>*)eventCallbackIds {
+    if (_eventCallbackIds == nil) _eventCallbackIds = @{}.mutableCopy;
+    return _eventCallbackIds;
+}
+
+UIViewController*(^RFSWRootViewController)(void) = ^UIViewController*(){
+    for (UIScene *scene in UIApplication.sharedApplication.connectedScenes)
+        if ([scene isKindOfClass:[UIWindowScene class]]) {
+            UIWindowScene *windowScene = (UIWindowScene *)scene;
+            for (UIWindow *window in windowScene.windows)
+                if (window.isKeyWindow)
+                    return window.rootViewController;
+        }
+    return nil;
+};
+
+- (void) exec:(CDVInvokedUrlCommand*)command {
+    NSString* method = command.arguments[0];
+    NSMutableArray* args = [NSMutableArray new];
+    for (int i = 1; i < command.arguments.count; i++) [args addObject:command.arguments[i]];
+    if ([method isEqualToString:@"setEvent"]) {
+        self.eventCallbackIds[args[0]] = command.callbackId;
+        return;
+    }
+    
+    RFSWEventSender sendEvent = ^(NSString* callbackId, id data) {
+        NSString* eventId = [self.eventCallbackIds objectForKey:callbackId];
+        if(eventId) callbackId = eventId;
+        data = [RFSWJSONConstructor toSendable:data];
+        CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:data];
+        [result setKeepCallbackAsBool:YES];
+        [self.commandDelegate sendPluginResult:result callbackId:callbackId];
+    };
+    
+    [RFSWMain methodCall:method :args :^(id data) { sendEvent(command.callbackId, data); } :sendEvent];
+}
+
+@end

package/ios/RFSWConfig.h

@@ -0,0 +1,27 @@
+#ifndef RFSWConfig_h
+#define RFSWConfig_h
+
+#import <FaceSDK/FaceSDK.h>
+#import "RFSWJSONConstructor.h"
+
+@interface RFSWConfig : NSObject
+
++(RFSFaceCaptureConfiguration* _Nonnull)faceCaptureConfigFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateFaceCaptureConfig:(RFSFaceCaptureConfiguration* _Nonnull)input;
+
++(RFSLivenessConfiguration* _Nonnull)livenessConfigFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateLivenessConfig:(RFSLivenessConfiguration* _Nonnull)input;
+
++(RFSMatchFacesConfiguration* _Nonnull)matchFacesConfigFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateMatchFacesConfig:(RFSMatchFacesConfiguration* _Nonnull)input;
+
+
++(void)setCustomization:(NSDictionary* _Nonnull)config :(RFSCustomization* _Nonnull)result;
+
++(RFSImageQualityCharacteristic* _Nonnull)imageQualityCharacteristicWithName:(NSString* _Nonnull)name
+                                                            recommendedRange:(NSArray<NSNumber*>* _Nullable)recommendedRange
+                                                                 customRange:(NSArray* _Nullable)customRange
+                                                                       color:(UIColor* _Nullable)color;
+
+@end
+#endif

package/ios/RFSWConfig.m

@@ -0,0 +1,199 @@
+#import "RFSWConfig.h"
+
+@implementation RFSWConfig
+
++(RFSFaceCaptureConfiguration*)faceCaptureConfigFromJSON:(NSDictionary*)input {
+    if (!input || [input isEqual:[NSNull null]])  return nil;
+    return [RFSFaceCaptureConfiguration configurationWithBuilder:^(RFSFaceCaptureConfigurationBuilder  * _Nonnull builder) {
+        for (NSString* key in input) {
+            id value = input[key];
+            NSDictionary* Switch = @{
+                @"copyright": ^{ [builder setCopyright:[value boolValue]]; },
+                @"cameraSwitchEnabled": ^{ [builder setCameraSwitchButtonEnabled:[value boolValue]]; },
+                @"closeButtonEnabled": ^{ [builder setCloseButtonEnabled:[value boolValue]]; },
+                @"torchButtonEnabled": ^{ [builder setTorchButtonEnabled:[value boolValue]]; },
+                @"vibrateOnSteps": ^{ [builder setVibrateOnSteps:[value boolValue]]; },
+                @"detectOcclusion": ^{ [builder setDetectOcclusion:[value boolValue]]; },
+                @"showFaceAnimation": ^{ [builder setShowFaceAnimation:[value boolValue]]; },
+                @"cameraPositionIOS": ^{ [builder setCameraPosition:[value integerValue]]; },
+                @"screenOrientation": ^{ [builder setScreenOrientation:[RFSWJSONConstructor screenOrienrationFromJSON:value]]; },
+                @"timeout": ^{ [builder setTimeoutInterval:value]; },
+                @"holdStillDuration": ^{ [builder setHoldStillDuration:value]; },
+            };
+            if(Switch[key]) ((void(^)(void))Switch[key])();
+        }
+    }];
+}
+
++(id)generateFaceCaptureConfig:(RFSFaceCaptureConfiguration*)input {
+    NSMutableDictionary* result = @{
+        @"copyright":@(input.copyright),
+        @"cameraSwitchEnabled":@(input.cameraSwitchButtonEnabled),
+        @"closeButtonEnabled":@(input.closeButtonEnabled),
+        @"torchButtonEnabled":@(input.torchButtonEnabled),
+        @"vibrateOnSteps":@(input.vibrateOnSteps),
+        @"detectOcclusion":@(input.detectOcclusion),
+        @"showFaceAnimation":@(input.showFaceAnimation),
+        @"cameraPositionIOS":@(input.cameraPosition),
+        @"screenOrientation":[RFSWJSONConstructor generateScreenOrienration:input.screenOrientation],
+    }.mutableCopy;
+    if (input.timeoutInterval) result[@"timeout"] = input.timeoutInterval;
+    if (input.holdStillDuration) result[@"holdStillDuration"] = input.holdStillDuration;
+    return result;
+}
+
++(RFSLivenessConfiguration*)livenessConfigFromJSON:(NSDictionary*)input {
+    if (!input || [input isEqual:[NSNull null]])  return nil;
+    return [RFSLivenessConfiguration configurationWithBuilder:^(RFSLivenessConfigurationBuilder  * _Nonnull builder) {
+        for (NSString* key in input) {
+            id value = input[key];
+            NSDictionary* Switch = @{
+                @"copyright": ^{ [builder setCopyright:[value boolValue]]; },
+                @"cameraSwitchEnabled": ^{ [builder setCameraSwitchButtonEnabled:[value boolValue]]; },
+                @"closeButtonEnabled": ^{ [builder setCloseButtonEnabled:[value boolValue]]; },
+                @"torchButtonEnabled": ^{ [builder setTorchButtonEnabled:[value boolValue]]; },
+                @"vibrateOnSteps": ^{ [builder setVibrateOnSteps:[value boolValue]]; },
+                @"cameraPositionIOS": ^{ [builder setCameraPosition:[value integerValue]]; },
+                @"attemptsCount": ^{ [builder setAttemptsCount:[value integerValue]]; },
+                @"locationTrackingEnabled": ^{ [builder setLocationTrackingEnabled:[value boolValue]]; },
+                @"recordingProcess": ^{ [builder setRecordingProcess:[value integerValue]]; },
+                @"livenessType": ^{ [builder setLivenessType:[value integerValue]]; },
+                @"screenOrientation": ^{ [builder setScreenOrientation:[RFSWJSONConstructor screenOrienrationFromJSON:value]]; },
+                @"tag": ^{ [builder setTag:value]; },
+                @"skipStep": ^{ [builder setStepSkippingMask:[RFSWJSONConstructor livenessStepSkipFromJSON:value]]; },
+                @"metadata": ^{ [builder setMetadata:value]; },
+            };
+            if(Switch[key]) ((void(^)(void))Switch[key])();
+        }
+    }];
+}
+
++(id)generateLivenessConfig:(RFSLivenessConfiguration*)input {
+    NSMutableDictionary* result = @{
+        @"copyright":@(input.copyright),
+        @"cameraSwitchEnabled":@(input.cameraSwitchButtonEnabled),
+        @"closeButtonEnabled":@(input.closeButtonEnabled),
+        @"torchButtonEnabled":@(input.torchButtonEnabled),
+        @"vibrateOnSteps":@(input.vibrateOnSteps),
+        @"cameraPositionIOS":@(input.cameraPosition),
+        @"attemptsCount":@(input.attemptsCount),
+        @"locationTrackingEnabled":@(input.locationTrackingEnabled),
+        @"recordingProcess":@(input.recordingProcess),
+        @"livenessType":@(input.livenessType),
+        @"screenOrientation":[RFSWJSONConstructor generateScreenOrienration:input.screenOrientation],
+        @"skipStep":[RFSWJSONConstructor generateLivenessStepSkip:input.stepSkippingMask],
+        @"metadata":input.metadata,
+    }.mutableCopy;
+    if (input.tag) result[@"tag"] = input.tag;
+    return result;
+}
+
++(RFSMatchFacesConfiguration*)matchFacesConfigFromJSON:(NSDictionary*)input {
+    if (!input || [input isEqual:[NSNull null]])  return nil;
+    return [RFSMatchFacesConfiguration configurationWithBuilder:^(RFSMatchFacesConfigurationBuilder  * _Nonnull builder) {
+        for (NSString* key in input) {
+            id value = input[key];
+            NSDictionary* Switch = @{
+                @"processingMode": ^{ [builder setProcessingMode:[value integerValue]]; },
+                @"locationTrackingEnabled": ^{ [builder setLocationTrackingEnabled:[value boolValue]]; },
+            };
+            if(Switch[key]) ((void(^)(void))Switch[key])();
+        }
+    }];
+}
+
++(id)generateMatchFacesConfig:(RFSMatchFacesConfiguration*)input {
+    return @{
+        @"processingMode":@(input.processingMode),
+        @"locationTrackingEnabled":@(input.locationTrackingEnabled),
+    };
+}
+
+// For some reason if you iterate over dictionary using NSNumber* or id,
+// it does't work as a key to dictionary unless you do this.
++(NSNumber*)toKey:(id)input {
+    return [NSNumber numberWithInt:[input intValue]];
+}
+
++(void)setCustomization:(NSDictionary*)config :(RFSCustomization*)result {
+    RFSUIConfiguration* uiConfig = [result configuration];
+    for (NSString* key in config) {
+        NSDictionary* value = config[key];
+        NSDictionary* Switch = @{
+            @"colors": ^{ for (id k in value) [uiConfig valueForKey:key][[RFSWConfig toKey:k]] = [RFSWJSONConstructor colorWithInt:value[k]]; },
+            @"fonts": ^{ for (id k in value) [uiConfig valueForKey:key][[RFSWConfig toKey:k]] = [RFSWJSONConstructor fontFromJSON:value[k]]; },
+            @"images": ^{ for (id k in value) [uiConfig valueForKey:key][[RFSWConfig toKey:k]] = [RFSWJSONConstructor imageWithBase64:value[k]]; },
+            @"uiCustomizationLayer": ^{ [result setCustomUILayerJSON:value]; },
+        };
+        ((void(^)(void))Switch[key])();
+    }
+}
+
++(id)imageQualityCharacteristicWithName:(NSString*)name recommendedRange:(NSArray*)recommendedRange customRange:(NSArray*)customRange color:(UIColor*)color {
+    __block RFSImageQualityCharacteristic* result = nil;
+    NSDictionary* Switch = @{
+        @"ImageWidth": ^{ result = [RFSImageCharacteristics imageWidthWithRange:recommendedRange]; },
+        @"ImageHeight": ^{ result = [RFSImageCharacteristics imageHeightWithRange:recommendedRange]; },
+        @"ImageWidthToHeight": ^{ result = [RFSImageCharacteristics imageWidthToHeightWithRange:recommendedRange]; },
+        @"ImageChannelsNumber": ^{ result = [RFSImageCharacteristics imageChannelsNumberWithValue:recommendedRange[0]]; },
+        @"PaddingRatio": ^{ result = [RFSImageCharacteristics paddingRatioWithMinValue:recommendedRange[0] maxValue:recommendedRange[1]]; },
+        @"ArtFace": ^{ result = RFSImageCharacteristics.artFace; },
+        
+        @"FaceMidPointHorizontalPosition": ^{ result = RFSHeadSizeAndPosition.faceMidPointHorizontalPosition; },
+        @"FaceMidPointVerticalPosition": ^{ result = RFSHeadSizeAndPosition.faceMidPointVerticalPosition; },
+        @"HeadWidthRatio": ^{ result = RFSHeadSizeAndPosition.headWidthRatio; },
+        @"HeadHeightRatio": ^{ result = RFSHeadSizeAndPosition.headHeightRatio; },
+        @"EyesDistance": ^{ result = RFSHeadSizeAndPosition.eyesDistance; },
+        @"Yaw": ^{ result = RFSHeadSizeAndPosition.yaw; },
+        @"Pitch": ^{ result = RFSHeadSizeAndPosition.pitch; },
+        @"Roll": ^{ result = RFSHeadSizeAndPosition.roll; },
+        
+        @"BlurLevel": ^{ result = RFSFaceImageQuality.blurLevel; },
+        @"NoiseLevel": ^{ result = RFSFaceImageQuality.noiseLevel; },
+        @"UnnaturalSkinTone": ^{ result = RFSFaceImageQuality.unnaturalSkinTone; },
+        @"FaceDynamicRange": ^{ result = RFSFaceImageQuality.faceDynamicRange; },
+        
+        @"EyeRightClosed": ^{ result = RFSEyesCharacteristics.eyeRightClosed; },
+        @"EyeLeftClosed": ^{ result = RFSEyesCharacteristics.eyeLeftClosed; },
+        @"EyeRightOccluded": ^{ result = RFSEyesCharacteristics.eyeRightOccluded; },
+        @"EyeLeftOccluded": ^{ result = RFSEyesCharacteristics.eyeLeftOccluded; },
+        @"EyesRed": ^{ result = RFSEyesCharacteristics.eyesRed; },
+        @"EyeRightCoveredWithHair": ^{ result = RFSEyesCharacteristics.eyeRightCoveredWithHair; },
+        @"EyeLeftCoveredWithHair": ^{ result = RFSEyesCharacteristics.eyeLeftCoveredWithHair; },
+        @"OffGaze": ^{ result = RFSEyesCharacteristics.offGaze; },
+        
+        @"TooDark": ^{ result = RFSShadowsAndLightning.tooDark; },
+        @"TooLight": ^{ result = RFSShadowsAndLightning.tooLight; },
+        @"FaceGlare": ^{ result = RFSShadowsAndLightning.faceGlare; },
+        @"ShadowsOnFace": ^{ result = RFSShadowsAndLightning.shadowsOnFace; },
+        
+        @"ShouldersPose": ^{ result = RFSPoseAndExpression.shouldersPose; },
+        @"ExpressionLevel": ^{ result = RFSPoseAndExpression.expressionLevel; },
+        @"MouthOpen": ^{ result = RFSPoseAndExpression.mouthOpen; },
+        @"Smile": ^{ result = RFSPoseAndExpression.smile; },
+        
+        @"DarkGlasses": ^{ result = RFSHeadOcclusion.darkGlasses; },
+        @"ReflectionOnGlasses": ^{ result = RFSHeadOcclusion.reflectionOnGlasses; },
+        @"FramesTooHeavy": ^{ result = RFSHeadOcclusion.framesTooHeavy; },
+        @"FaceOccluded": ^{ result = RFSHeadOcclusion.faceOccluded; },
+        @"HeadCovering": ^{ result = RFSHeadOcclusion.headCovering; },
+        @"ForeheadCovering": ^{ result = RFSHeadOcclusion.foreheadCovering; },
+        @"StrongMakeup": ^{ result = RFSHeadOcclusion.strongMakeup; },
+        @"Headphones": ^{ result = RFSHeadOcclusion.headphones; },
+        @"MedicalMask": ^{ result = RFSHeadOcclusion.medicalMask; },
+        
+        @"BackgroundUniformity": ^{ result = RFSQualityBackground.backgroundUniformity; },
+        @"ShadowsOnBackground": ^{ result = RFSQualityBackground.shadowsOnBackground; },
+        @"OtherFaces": ^{ result = RFSQualityBackground.otherFaces; },
+        @"BackgroundColorMatch": ^{
+            if (color) result = [RFSQualityBackground backgroundColorMatchWithColor:color];
+            else result = RFSQualityBackground.backgroundColorMatch;
+        },
+    };
+    ((void(^)(void))Switch[name])();
+    if (!result) [NSException raise:@"RFSImageQualityCharacteristic" format:@"name not found"];
+    if (customRange) result = [result withCustomRange:customRange];
+    return result;
+}
+
+@end

package/ios/RFSWJSONConstructor.h

@@ -0,0 +1,135 @@
+#ifndef RFSWJSONConstructor_h
+#define RFSWJSONConstructor_h
+
+#import <FaceSDK/FaceSDK.h>
+#import "RFSWConfig.h"
+
+@interface RFSWJSONConstructor : NSObject
+
++(NSString* _Nullable)toSendable:(id _Nullable)input;
++(id _Nonnull)generateArray:(NSArray* _Nullable)input :(SEL _Nonnull)toJson;
++(id _Nullable)arrayFromJSON:(NSArray* _Nullable)input :(SEL _Nonnull)fromJson;
++(id _Nullable)base64Encode:(NSData* _Nullable)input;
++(id _Nullable)imageWithBase64:(NSString* _Nullable)input;
+
++(UIFont* _Nonnull)fontFromJSON:(NSDictionary* _Nonnull)input;
++(RFSLivenessStepSkip)livenessStepSkipFromJSON:(NSArray<NSNumber*>* _Nonnull)input;
++(NSArray<NSNumber*>* _Nonnull)generateLivenessStepSkip:(RFSLivenessStepSkip)input;
++(RFSScreenOrientation)screenOrienrationFromJSON:(NSArray<NSNumber*>* _Nonnull)input;
++(NSArray<NSNumber*>* _Nonnull)generateScreenOrienration:(RFSScreenOrientation)input;
++(UIColor* _Nonnull)colorWithInt:(NSNumber* _Nonnull)input;
+
++(id _Nonnull)generateInitCompletion:(BOOL)success :(NSError* _Nullable)error;
++(id _Nonnull)generateVideoEncoderCompletion:(NSString* _Nonnull)transactionId :(BOOL)success;
++(id _Nonnull)generateComparedFacesSplit:(RFSMatchFacesSimilarityThresholdSplit* _Nonnull)input;
++(id _Nonnull)generatePersonDBResponse:(id _Nullable)data :(NSError* _Nullable)error;
++(id _Nonnull)idFromJSON:(NSDictionary* _Nonnull)input;
++(id _Nonnull)updatePersonFromJSON:(RFSPerson* _Nonnull)result :(NSDictionary* _Nonnull)json;
++(id _Nonnull)updatePersonGroupFromJSON:(RFSPersonGroup* _Nonnull)result :(NSDictionary* _Nonnull)json;
+
+
++(RFSPoint* _Nonnull)pointFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generatePoint:(RFSPoint* _Nonnull)input;
+
++(CGRect)rectFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateRect:(CGRect)input;
+
++(CGSize)sizeFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateSize:(CGSize)input;
+
++(RFSOutputImageCrop* _Nonnull)outputImageCropFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateOutputImageCrop:(RFSOutputImageCrop* _Nonnull)input;
+
++(RFSOutputImageParams* _Nonnull)outputImageParamsFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateOutputImageParams:(RFSOutputImageParams* _Nonnull)input;
+
++(RFSImageQualityRange* _Nonnull)imageQualityRangeFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateImageQualityRange:(RFSImageQualityRange* _Nonnull)input;
+
++(RFSImageQualityResult* _Nonnull)imageQualityResultFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateImageQualityResult:(RFSImageQualityResult* _Nonnull)input;
+
++(RFSImageQualityCharacteristic* _Nonnull)imageQualityCharacteristicFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateImageQualityCharacteristic:(RFSImageQualityCharacteristic* _Nonnull)input;
+
++(NSDictionary<NSString*, id>* _Nonnull)generateFaceSDKVersion:(RFSFaceSDKVersion* _Nonnull)input;
+
++(RFSInitializationConfiguration* _Nonnull)initConfigFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateInitConfig:(RFSInitializationConfiguration* _Nonnull)input;
+
++(RFSDetectFacesAttributeResult* _Nonnull)detectFacesAttributeResultFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateDetectFacesAttributeResult:(RFSDetectFacesAttributeResult* _Nonnull)input;
+
++(RFSDetectFaceResult* _Nonnull)detectFaceResultFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateDetectFaceResult:(RFSDetectFaceResult* _Nonnull)input;
+
++(RFSDetectFacesConfiguration* _Nonnull)detectFacesConfigFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateDetectFacesConfig:(RFSDetectFacesConfiguration* _Nonnull)input;
+
++(RFSDetectFacesRequest* _Nonnull)detectFacesRequestFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateDetectFacesRequest:(RFSDetectFacesRequest* _Nonnull)input;
+
++(RFSDetectFacesResponse* _Nonnull)detectFacesResponseFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateDetectFacesResponse:(RFSDetectFacesResponse* _Nonnull)input;
+
++(RFSImage* _Nonnull)faceCaptureImageFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateFaceCaptureImage:(RFSImage* _Nonnull)input;
+
++(RFSFaceCaptureResponse* _Nonnull)faceCaptureResponseFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateFaceCaptureResponse:(RFSFaceCaptureResponse* _Nonnull)input;
+
++(RFSLivenessResponse* _Nonnull)livenessResponseFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateLivenessResponse:(RFSLivenessResponse* _Nonnull)input;
+
++(id _Nonnull)generateLivenessNotification:(RFSLivenessProcessStatus)status result:(RFSLivenessResponse* _Nullable)response;
+
++(RFSMatchFacesImage* _Nonnull)matchFacesImageFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateMatchFacesImage:(RFSMatchFacesImage* _Nonnull)input;
+
++(RFSMatchFacesRequest* _Nonnull)matchFacesRequestFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateMatchFacesRequest:(RFSMatchFacesRequest* _Nonnull)input;
+
++(RFSMatchFacesDetectionFace* _Nonnull)matchFacesDetectionFaceFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateMatchFacesDetectionFace:(RFSMatchFacesDetectionFace* _Nonnull)input;
+
++(RFSMatchFacesDetection* _Nonnull)matchFacesDetectionFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateMatchFacesDetection:(RFSMatchFacesDetection* _Nonnull)input;
+
++(RFSMatchFacesComparedFace* _Nonnull)comparedFaceFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateComparedFace:(RFSMatchFacesComparedFace* _Nonnull)input;
+
++(RFSMatchFacesComparedFacesPair* _Nonnull)comparedFacesPairFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateComparedFacesPair:(RFSMatchFacesComparedFacesPair* _Nonnull)input;
+
++(RFSMatchFacesResponse* _Nonnull)matchFacesResponseFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateMatchFacesResponse:(RFSMatchFacesResponse* _Nonnull)input;
+
++(RFSEditGroupPersonsRequest* _Nonnull)editGroupPersonsRequestFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateEditGroupPersonsRequest:(RFSEditGroupPersonsRequest* _Nonnull)input;
+
++(RFSImageUpload* _Nonnull)imageUploadFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateImageUpload:(RFSImageUpload* _Nonnull)input;
+
++(RFSPerson* _Nonnull)personFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generatePerson:(RFSPerson* _Nonnull)input;
+
++(RFSPersonGroup* _Nonnull)personGroupFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generatePersonGroup:(RFSPersonGroup* _Nonnull)input;
+
++(RFSPersonImage* _Nonnull)personImageFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generatePersonImage:(RFSPersonImage* _Nonnull)input;
+
++(RFSSearchPersonDetection* _Nonnull)searchPersonDetectionFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateSearchPersonDetection:(RFSSearchPersonDetection* _Nonnull)input;
+
++(RFSSearchPersonImage* _Nonnull)searchPersonImageFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateSearchPersonImage:(RFSSearchPersonImage* _Nonnull)input;
+
++(RFSSearchPerson* _Nonnull)searchPersonFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateSearchPerson:(RFSSearchPerson* _Nonnull)input;
+
++(RFSSearchPersonRequest* _Nonnull)searchPersonRequestFromJSON:(id _Nonnull)input;
++(NSDictionary<NSString*, id>* _Nonnull)generateSearchPersonRequest:(RFSSearchPersonRequest* _Nonnull)input;
+
+@end
+#endif