iOS - Face Module¶

The Face Module performs liveness detection and face comparison with the photo on the identity card. Additionally, video recording can be optionally obtained during the flow.

Introduction¶

The Face Module analyzes whether the person is a real individual through images taken from the front camera. The module can detect facial expressions and movements such as smiling, blinking, turning the head to the left or right, and looking up, in addition to facial recognition technology.

It is essential that the face is correctly aligned with the camera during the analysis process. Moreover, the analysis duration may vary depending on the device's performance and camera quality. This module provides an effective and reliable solution, especially in authentication processes that require liveness detection.

atlassian-warning#FFEBE6

When the Face Module is intended to be used, the Core Module must be added to the project. This is necessary to provide the basic functionalities of the modules.

Integration Steps for EnQualifyFace SDK into the Project¶

This guide explains how to integrate EnQualifyFace SDK into the project. You can achieve a quick and easy integration by following the steps below.

What is Core Module¶

Before adding the Face Module, the Core Module should be included in the project. You can visit the Core Module documentation for information on how to add the Core Module.

What is EnQualifyFace¶

EnQualifyFace is designed as a facial recognition and verification (liveness detection) SDK. This module is designed to perform liveness detection in remote identity verification processes.

EnQualifyFace can do the following:

1. Face Detection: Detects the face of the user in front of the camera.

2. Liveness Control: Confirms that the person is a live human by requesting different movements:

3. Smile detection

4. Blink detection
5. Turning the face to the left, right, and up
6. Face Comparison: Can compare the acquired face image with the face photo on the identity document or NFC chip.

Quick Implementation¶

For rapid integration in your project, you can refer to the section How to Implement Face Module?.

Adding Face Module to the Project¶

The EnQualify iOS SDK can be directly integrated into the project:

• Method: Add the SDK by embedding the xcframework directly into the project and install the required dependencies through CocoaPods.

// target 'MySampleProject' do
  use_frameworks!
  pod 'GoogleMLKit/FaceDetection', '7.0.0' # Face and Liveness Detection
end


post_install do |installer|
   installer.pods_project.targets.each do |target|
    target.build_configurations.each do |config|
        config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
        config.build_settings['EXPANDED_CODE_SIGN_IDENTITY'] = ""
        config.build_settings['CODE_SIGNING_REQUIRED'] = "NO"
        config.build_settings['CODE_SIGNING_ALLOWED'] = "NO"
        config.build_settings["EXCLUDED_ARCHS[sdk=iphonesimulator*]"] = ""
        config.build_settings['VALID_ARCHS'] = "arm64 x86_64"
        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '15.5'
        config.build_settings["ONLY_ACTIVE_ARCH"] = "YES"
    end
  end
end

Explanation of Build Settings After Installation¶

BUILD_LIBRARY_FOR_DISTRIBUTION = YES:¶

Ensures that the framework is built for distribution, allowing it to be used as a binary or shared framework in other projects. This is particularly beneficial when creating XCFrameworks.

EXPANDED_CODE_SIGN_IDENTITY = "":¶

Clears the Code Signing Identity; thus ensuring that no specific certificate is used during the build process.

CODE_SIGNING_REQUIRED = NO:¶

Disables the code signing requirement during the build process. This is useful during testing or in situations where signing is not necessary.

CODE_SIGNING_ALLOWED = NO:¶

Ensures that code signing is completely disabled.

EXCLUDED_ARCHS[sdk=iphonesimulator*] = "":¶

Removes all architectures that are excluded for the iPhone simulator. This setting ensures compatibility during the build process.

VALID_ARCHS = "arm64 x86_64":¶

Specifies the valid architectures for the build. Here, arm64 (M Series) is used for Macs with Apple silicon and x86_64 for Intel-based Macs.

IPHONEOS_DEPLOYMENT_TARGET = 14.0:¶

Sets the minimum iOS version that the application or framework supports. This ensures compatibility with devices running iOS 14.0 and above.

ONLY_ACTIVE_ARCH = YES:¶

Limits the build process to only the architecture of the active build device or simulator. This can speed up build time during development.

XCFrameworks¶

• To integrate the EnQualify SDK directly into your project, you can add the base SDK files—OCRModule.xcframework, NFCModule.xcframework, FaceModule.xcframework, CoreModule.xcframework, and VideoCallModule.xcframework—directly to your project files.
• Alternatively, if you have already copied the XCFrameworks into your project, you can go to the Project Settings > General section and select Embed and Sign to add these frameworks to your project.
• For the dependencies of the EnQualify SDK added this way, you need to include them in your project with the version numbers specified in the "podspec" file for the relevant version or determined by the provider.

How to Implement Face Module?¶

1. Adding Modules¶

1.1 Implementing Core Module¶

The Core Module must be included in the project before using the EnQualifyFace Module. If you haven't added it yet, you can check the Core Module documentation for details.

1.2 Adding Face Module to the Project¶

You can find the necessary instructions for integrating the Face Module under the title Adding Face Module to the Project. Follow these steps to integrate the Face module into your project.

2. Permissions¶

2.1 Adding Camera Permission to Info.plist File¶

First, you need to add camera permission to the Info.plist file. This allows your application to access the camera hardware.

<key>NSCameraUsageDescription</key>

2.2 Requesting Runtime Permission¶

The camera permission is requested within the initialize function.

EnQualifyFace.initialize(_ sender: Any?, 
                        sessionModel: SessionModelFace? = nil, 
                        baseModel: BaseModelFace? = nil)

If the camera permission is not granted, the initializeFailed(with key: CustomNSError) delegate is triggered. If permission is granted, the initializeCompleted(moduleName: String) delegate is triggered.

3. Adding EnQualifyFaceDelegate Interface¶

EnQualifyFaceDelegate contains the necessary delegate methods to manage Face operations. By implementing this interface, you can listen to and manage events related to Face. For detailed information, please refer to the EnQualifyFace User Guide.

3.1 Adding EnQualifyFaceDelegate to Class¶

class ViewController: EnQualifyFaceDelegate {

3.2 Overriding Delegate Functions¶

class ViewController: EnQualifyFaceDelegate {

     func faceDetected() {}

     func smileDetected() {}

     func eyeCloseDetected() {}

     func faceLeftDetected() {}

     func faceRightDetected() {}

     func faceUpDetected() {}

     func faceCompleted() {}

     func livenessFailed(error: EnQualifyFaceError) {}

     func faceFailed(error: EnQualifyFaceError) {}

     func faceDetectFailed(error: EnQualifyFaceError) {}

     func faceCompareCompleted() {}

     func faceCompareFailed(error: EnQualifyFaceError) {}

     func initializeCompleted(moduleName: String) {}

     func initializeFailed(with key: CustomNSError) {}

     func sessionCloseCompleted(status: String) {}

     func sessionCloseFailed() {}

     func tokenCreateCompleted() {}

     func tokenCreateFailed() {}

     func integrationAddCompleted() {}

     func integrationAddFailed() {}

     func sessionAddFailed() {}

     func settingGetFailed() {}

     func signingSetCompleted() {}

     func signingCompleted() {}

     func signingSetFailed(error: String) {}
}

4. Initializing EnQualifyFace and Token, Settings, and Session Operations¶

Before initialization;

• The EnQualifyFaceDelegate methods should be added to the delegate area of the UIViewController in which they will be used.
• SessionModelFace is a model containing the parameters that will be used to start Face, and this model should be added to the relevant field during the initialization process. For detailed information, refer to the SessionModelFace section.
• BaseModelFace is a model containing the certificate and base URL information necessary for Face, and this model should be added to the relevant field during the initialization process. For detailed information, refer to the BaseModelFace section.

Before starting Face operations, the EnQualifyFace class must be initialized. This process triggers the necessary token, settings, and session operations. Additionally, it is important to inform the user that the preparations for the Face operation are complete and then start the process.

func initialize(_ sender: Any?,
                sessionModel: SessionModelFace? = nil,
                baseModel: BaseModelFace? = nil) {

Parameters¶

After EnQualifyFace is initialized, an instance of EnQualifyFace is created, and then the necessary operations are triggered to create the token, settings, and session. After initialization, the token, settings, and session are managed by the SDK.

After the EnQualifyFace instance is created, the following steps are sequentially carried out:

1. Token Creation

2. EnQualifyFace initiates the token creation process.

3. If an error occurs during the token creation process, the tokenCreateFailed delegate is triggered.

func tokenCreateFailed() {}

• After the token is successfully created, the process transitions to the session operation, which is the next step.

• Starting Session Operation

• After the token is successfully obtained, the session initiation process kicks in.

• If an error occurs during session initiation, the sessionAddFailed delegate is triggered.

func sessionAddFailed() {}

• When the session operation is completed successfully, the SDK establishes a connection with the back office and is ready to start the process.

• Getting Settings

• After the session is created successfully, the process of retrieving the settings defined in the back office is initiated.

• If an error occurs during this process, the settingsGetFailed delegate is triggered, and the error message is sent to the client side.

func settingGetFailed() {}

• When the settings are successfully retrieved, the SDK performs the corresponding configurations and starts the session operation.

• Completing the Process

• When all steps are completed seamlessly, the initializeCompleted delegate is triggered. This indicates that the SDK has been successfully initialized and is ready for Face operations.

func initializeCompleted(moduleName: String) {}

This process is designed to ensure that EnQualifyFace functions seamlessly. Possible errors are communicated to the client or user through the respective delegates, facilitating necessary actions.

5. Starting Face Operation¶

In this section, we explain step by step how to initiate and manage Face operations.

5.1 User Notification¶

It is recommended to inform the user before starting the Face operation. For this, a FaceInfo page can be created.
This page provides the user with information about the Face operation and enhances user experience.

5.2 Face Operations¶

For detailed information about functions and delegates related to Face, please refer to the EnQualifyFace User Guide.

• setTotalSteps(_ steps: Int)
• faceDetect(in viewController: UIViewController, cameraPosition: AVCaptureDevice.Position = .front)
• eyeCloseDetect()
• smileDetect()
• faceRightDetect()
• faceLeftDetect()
• faceUpDetect()
• faceComplete(withDelay delay: TimeInterval = 0.0)
• sessionClose(finished: Bool)

5.2.1. Adding Total Steps¶

To determine how many phases will be displayed in the on-screen progress visual, setTotalSteps(_ steps: Int) is called.

EnQualifyFace.setTotalSteps(6)

5.2.3 Performing Face Recognition¶

To start the face detection process, the faceDetect(in viewController: UIViewController, cameraPosition: AVCaptureDevice.Position = .front) function is used. This operation is managed by the EnQualify Face API and is called as follows:

EnQualifyFace.faceDetect(in: self)

Delegate Mechanism

When the face detection process is successfully completed, the faceDetected delegate is triggered. Within this delegate, other operations that need to be performed after the process can be handled.

func faceDetected() {}

5.2.4 Performing Smile Detection¶

To initiate the smile detection, the smileDetect() function is used. This operation is managed by EnQualifyFace and is called as follows:

EnQualifyFace.smileDetect()

Delegate Mechanism

When the smile detection process is successfully completed, the smileDetected() delegate is triggered. This delegate can handle other operations that need to be performed after the process.

func smileDetected() {}

5.2.5 Performing Eye Close Detection¶

To initiate the eye close detection, the eyeCloseDetect() function is used. This operation is managed by EnQualifyFace and is called as follows:

EnQualifyFace.eyeCloseDetect()

Delegate Mechanism

When the eye close detection process is successfully completed, the eyeCloseDetected() delegate is triggered. This delegate can address other operations that need to be performed after the process.

func eyeCloseDetected() {}

5.2.6 Performing Head Turn Detection to the Right¶

To initiate the head turn detection to the right, the faceRightDetect() function is used. This operation is managed by EnQualifyFace and is called as follows:

EnQualifyFace.faceRightDetect()

Delegate Mechanism

When the head turn to the right is successfully detected, the faceRightDetected() delegate is triggered. This delegate can handle other operations that need to be performed after the process.

func faceRightDetected() {}

5.2.7 Performing Head Turn Detection to the Left¶

To initiate the head turn detection to the left, the faceLeftDetect() function is used. This operation is managed by EnQualifyFace and is called as follows:

EnQualifyFace.faceLeftDetect()

Delegate Mechanism

When the head turn to the left is successfully detected, the faceLeftDetected() delegate is triggered. This delegate can handle other operations that need to be performed after the process.

func faceLeftDetected() {}

5.2.8 Performing Head Up Detection¶

To initiate the head up detection, the faceUpDetect() function is used. This operation is managed by EnQualifyFace and is called as follows:

EnQualifyFace.faceUpDetect()

Delegate Mechanism

When the head up detection is successfully completed, the faceUpDetected() delegate is triggered. This delegate can handle other operations that need to be performed after the process.

func faceUpDetected() {}

5.2.9. Informing that the Liveness Stream Has Completed¶

Once all face recognition steps are completed, the faceComplete(withDelay delay: TimeInterval = 0.0) function is used to notify the SDK that the processes have ended. This function also stops the analyses done from the camera, concludes the processing, and triggers the process of sending the read data to the back office.

EnQualifyFace.faceComplete(withDelay delay: TimeInterval = 0.0)

When the read data transmission to the back office is completed, the faceCompleted***()*** delegate is triggered, and the comparison process is initiated with the faceCompare function.

func faceCompleted() {
    EnQualifyFace.faceCompare()
}

5.2.10. Comparing the Liveness Image¶

The similarity rates can be calculated between biometric photos obtained from NFC and OCR and the liveness photo obtained during the liveness step. To initiate this calculation, the faceCompare() function is used, and consequently, the faceCompareCompleted() and faceCompareFailed() delegates are triggered.

EnQualifyFace.faceCompare()

If an error occurs during the comparison, the faceCompareFailed delegate is triggered. This delegate is used to manage operations that need to be performed in the error case. When the comparison process is successfully completed, the analysis results are automatically communicated to the back office system. After the data transmission is completed, the faceCompareCompleted() delegate is triggered, indicating that the process has successfully concluded.

func faceCompareCompleted() {}

After the liveness operation is completed, the results page can be opened or transition to the next operation can be executed.

5.2.11. Closing the SDK Session¶

Closing Session Operation

To close the session used by SDKs for communication with backend services, the closeSession function is utilized. This process is managed by the EnQualifyCore API, but it is called in the API side of each SDK as follows.

atlassian-warning#FFEBE6

After a session is closed by an SDK, if it will be reused, the SDK must be initialized again.

EnQualifyFace.sessionClose(finished: Bool)

Delegate Mechanism

When the session closing operation is successfully completed, the sessionCloseCompleted delegate within the activity is triggered. This delegate can handle other actions that need to be performed after the process.

func sessionCloseCompleted(status: String) {}

When session closing fails, the sessionCloseFailed delegate within the activity is triggered. This delegate can handle other operations that need to be performed after the process.

func sessionCloseFailed() {}

Note:¶

To display the read data on the results page, you can refer to the CustomerFace section. This section ensures that the read data is presented to the user in a clear and understandable manner.

EnQualifyFace User Guide¶

EnQualifyFace is used for facial recognition and liveness detection operations. Below are the relevant functions and delegates explained.

Functions¶

initialize(...) : EnQualifyFace

func initialize(_ sender: Any?,
                sessionModel: SessionModelFace? = nil,
                baseModel: BaseModelFace? = nil) {

• sender: Any : Determines which class will handle the application's delegate methods.
• sessionModel: SessionModelFace : Contains the session information to be used during the Face operation.
• baseModel: BaseModelFace : Model carrying the basic data in the verification process.

The API works in a singleton structure, so operations are performed through the same instance throughout the application session. This saves resources and increases the consistency of the process. The initialization process automatically performs the following operations:

• Token creation
• Settings configuration
• Session initiation If a session already exists, a new session is not created, and the current session continues to be used.

faceDetect()

Detects whether a face is detected in the camera. This function serves as the basic starting step for other operations. Default Control Value: The process is considered successful when the face is detected within the X, Y axis range of -15 <= X <= 15, -15 <= Y <= 15.

smileDetect()

Detects whether there is a smile on the face. Smiling is a common gesture in liveness detection. Default Control Value: The smile value is considered successful when it is above 0.9.

eyeCloseDetect()

Detects whether the eyes are closed. Blinking or keeping the eyes closed is a common criterion in liveness detection. Default Control Value: Either the left or right eye is closed. It is considered successful when the eye closure value is lower than 0.3.

faceRightDetect()

Detects whether the person has turned their head to the right. This action is an optional validation step in liveness detection. Default Control Value: It is considered successful when the head is turned 15° or more to the right.

faceLeftDetect()

Detects whether the person has turned their head to the left. It works similarly to the right turn detection. Default Control Value: It is considered successful when the head is turned 15° or more to the left.

faceUpDetect()

Detects whether the person has raised their head. This action is a common validation method during liveness detection. Default Control Value: It is considered successful when the head is raised 10° or more.

faceComplete()

This function informs the SDK that all face recognition steps are completed, stops the camera analysis, and initiates the process of sending the read data to the back office.

faceCompare()

Compares the face detected by the camera with the biometric photo within the data of the identity chip and the OCR. It is used in identity verification processes.

Delegates¶

Token / Session / Settings Delegates¶

tokenCreateCompleted()

• Triggered when the token creation process is completed.
• If there is an existing token, it is not recreated, and the current token is used.

tokenCreateFailed()

• Triggered when an error occurs during token creation.

settingsGetFailed()

• Triggered when an error occurs while fetching settings information.

sessionAddFailed()

• Triggered when an error occurs while creating a new session.

sessionCloseCompleted(status: String)

• Triggered when the session is closed.

• Parameter:

• status : Status information of the session when it is closed.

sessionCloseFailed()

• Triggered when an error occurs while closing the session.

integrationAddCompleted()

• Triggered when the request to the IntegrationAdd service is completed.

integrationAddFailed()

• Triggered when an error occurs while making a request to the IntegrationAdd service.

initializeCompleted(module: String)

• Triggered after the EnQualifyFace module is initialized, and the token, settings, and session operations are successfully completed.

Processing flow should be determined according to the initiated module. * Parameter:

• module: The name of the initiated module.

Face Callbacks

faceDetected()

• Triggered when a face is detected in the camera. This event serves as a fundamental step for starting the liveness detection process.

smileDetected()

• Triggered when the user's smile gesture is detected. This is one of the expected actions during liveness detection.

eyeCloseDetected()

• Triggered when the eyes are detected as closed. This function is used in situations where the user is expected to blink or keep their eyes closed for a certain period.

faceRightDetected()

• Triggered when the user's head is detected to have turned to the right. It is used for direction validation within the scope of liveness detection.

faceLeftDetected()

• Triggered when the user's head is detected to have turned to the left. It is used for direction validation within the scope of liveness detection.

faceUpDetected()

• Triggered when the user's head is detected to have been lifted. It is used for direction validation within the scope of liveness detection.

faceCompareStarted()

• Triggered when the face comparison process begins.

faceCompareCompleted()

• Triggered when the face comparison process is successfully completed. This indicates that there is a sufficient match between the real-time face and the recorded face data.

faceCompareFailed(error: EnQualifyFaceError)

• Triggered when the face comparison process fails.

• Parameter:

• error: Detailed message regarding the comparison error.

livenessFailed(error: EnQualifyFaceError)

• Triggered when the liveness analysis fails.

• Parameter:

• error: Error code

faceDetectFailed(error: EnQualifyFaceError)

• Triggered when the face detection process fails.

• Parameter:

• error: Error code

faceSaveStarted()

• Triggered when the reading of the face data from the device is completed and this data starts to be sent to the back office.

faceCompleted()

• Triggered when the face comparison and liveness control processes are successfully completed. This event indicates that the real-time face has successfully matched with the registered face data and the entire process has been concluded.

faceFailed(error: EnQualifyFaceError)

public enum EnQualifyFaceError: Error {
    case timeout(FaceState, String)
    case detection(String)
    case liveness(String)
    case comparison(String)
    case camera(String)

    public var faceLocalizedDescription: String {
        switch self {
        case .timeout(let state, let message):
            return "Timeout during \(state) state: \(message)"
        case .detection(let message),
             .liveness(let message),
             .comparison(let message),
             .camera(let message):
            return message
        }
    }
}

• Triggered when an error is encountered in Face operations or when it fails.

• Parameters:

• faceLocalizedDescription: Error message.

Models¶

BaseModelFace¶

BaseModelFace is a data model containing the certificate information used in verification processes and the server connection address. Signaling (Communication) and MAPI (Mobile-Application Programming Interface) certificates are stored in both file (.der) format and Base64 text format.

Model¶

class BaseModelFace(
    var signallingCertificateList: [String]? = nil
    var mapiCertificateList: [String]? = nil
    var signallingCertificateBase64List: [String]? = nil
    var mapiCertificateBase64List: [String]? = nil
    var baseURL: String //Required field
    var locale: String? = nil
    var mobileUser: String? = nil
    var countryCode: String? = nil
)

Properties¶

Usage Example¶

In the following example, a BaseModelFace instance is created, defining certificate information and the server address.

var baseModelFace = BaseModelFace(
    signallingCertificateList: ["AI_CERT_1", "AI_CERT_2"],
    mapiCertificateList: ["MAPI_CERT_1", "MAPI_CERT_2"],
    signallingCertificateBase64List: ["QUlDRVJU...", "Q0VSVF8y..."],
    mapiCertificateBase64List: ["TU9SRSB...", "Q0VSVF8z..."],
    baseURL: "API_SERVER_URL",
    locale: "TR",
    mobileUser: "mobile",
    countryCode: "TUR"
)

Explanations¶

• Certificates (signallingCertificateList, mapiCertificateList): The certificate information is stored in file format.
• Base64 Certificates (signallingCertificateList, mapiCertificateBase64List): The certificates' versions converted into Base64 text format.
• Server Connection (baseURL): The server URL where authentication or certificate processes will be carried out.

SessionModelFace¶

SessionModelFace is a data model that contains user and identity information during a call session. It includes the type of call, user details, identity data, and additional parameters related to the session.

Model Definition¶

class SessionModelFace(
    var callType: String, // Required field
    var userName: String? = nil,
    var surname: String? = nil,
    var phone: String? = nil,
    var email: String? = nil,
    var identityType: String? = nil,
    var identityNo: String? = nil,
    var reference: String, // Required field
    var canAutoClose: Bool = false, // Default: false
    var isContinue: Bool = false, // Default: false
    var category: String? = nil,
    var taxNumber: String? = nil,
    var businessReference: String? = nil,
    var handicapped: Bool? = false
)

Properties¶

Usage Example¶

In the following example, a SessionModelFace instance is created to define the session information:

var sessionModelFace = SessionModelFace(
    callType: "NewCustomer",
    userName: "Enqura",
    surname: "Information",
    phone: "+905551234567",
    email: "enqualifyplus@enqura.com",
    identityType: "National ID Card",
    identityNo: "12345678901",
    reference: "REF123456",
    canAutoClose: true,
    isContinue: true,
    category: "category",
    taxNumber: "9876543210",
    businessReference: "COMPANY",
    handicapped: false
)

Explanations¶

• Required Fields: The callType and reference parameters must be specified.
• User Information: Fields like userName, surname, phone, email are optional.
• Identity Information: The identityType and identityNo can be used in NFC verification or identity identification processes.
• Handicap Status: The handicapped parameter indicates whether the user has special requirements.
• Auto Close: The canAutoClose can allow the session to close automatically when a certain condition occurs.
• Continuation Status: The isContinue checks whether the session is an ongoing process.

CustomerFace¶

These values are various parameters and metrics used for face recognition and liveness detection operations. Each is utilized to track features such as face recognition, movement detection, eye detection, and identity verification.

``` @objc public class CustomerFace: NSObject { @objc public static let shared = CustomerFace()

// MARK: - Image Getters
@objc public func getFaceDetectedImage() -> UIImage? {}

@objc public func getSmilingDetectedImage() -> UIImage? {}

@objc public func getFaceLeftDetectedImage() -> UIImage? {}

@objc public func getFaceRightDetectedImage() -> UIImage? {}

@objc public func getFaceUpDetectedImage() -> UIImage? {}

@objc public func getEyeCloseDetectedImage() -> UIImage? {}

@objc public func getEyeCloseIntervalDetectedImage() -> UIImage? {}

@objc public func getEyeOpenIntervalDetectedImage() -> UIImage? {}

// MARK: - Angle Getters
@objc public func getFaceLeftAngle() -> CGFloat {}

@objc public func getFaceRightAngle() -> CGFloat {}

@objc public func getFaceUpAngle() -> CGFloat {}

// MARK: - Eye Measurement Getters
@objc public func getOpennessOfLeftEye() -> Float {}

@objc public func getOpennessOfRightEye() -> Float {}

// MARK: - Confidence and Distance Getters
@objc public func getChipConfidence() -> Int {}

@objc public func getChipDistance() -> Double {}

@objc public func getIdDocConfidence() -> Int {}

@objc public func getIdDocDistance() -> Double {}

@objc public func getAntiSpoofing() -> Double {}

// MARK: - Eye Confidence Getters
@objc public func getLeftEyeCloseConfidence() -> CGFloat {}

@objc public func getRightEyeCloseConfidence() -> CGFloat {}

@objc public func getSmilingConfidence() -> CGFloat {}

// MARK: - Validity Level Getters
@objc public func getIdDocDistanceValidityLevel() -> Int {}

@objc public func getChipDistanceValidityLevel() -> Int {}

@objc public func getAntiSpoofingValidityLevel() -> Int {}

// MARK: - Eye Close Capture Getters
@objc public func getEyeCloseCaptureAntispoofing() -> Float {}

@objc public func getEyeCloseCaptureConfidence() -> Float {}

@objc public func getEyeCloseCaptureDistance() -> Float {}

@objc public func getEyeCloseCaptureDistanceValidityLevel() -> Int {}

@objc public func getEyeCloseCaptureAntispoofingValidityLevel() -> Int {}

// MARK: - Eye Close Capture Setters
@objc public func setEyeCloseCaptureAntispoofing(_ value: Float) {}

@objc public func setEyeCloseCaptureConfidence(_