uqudosdk-capacitor 2.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2022] [uqudo]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,20 @@
+# uqudo SDK Capacitor plugin
+
+The Official uqudo SDK wrapper for the Android and iOS SDKs.\
+Onboard new users faster, easier, and cheaper with an experience that seamlessly fits into your onboarding journey. Fully supported across the Middle East & Africa.
+
+### Platform specifics
+
+Plugin implementation is in folder `src`, while platform specific implementations are in `android` and `ios` folders.
+
+#### Android
+
+https://docs.uqudo.com
+
+#### iOS
+
+https://docs.uqudo.com
+
+## Licensing
+
+- In order to use the SDK you require a valid license. Contact us at https://uqudo.com/contact-us/

package/UqudosdkCapacitor.podspec

@@ -0,0 +1,19 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name =  "UqudosdkCapacitor"
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['homepage']
+  s.author = package['author']
+  s.source = { :http => 'https://uqudo.com' }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '12.0'
+  s.dependency 'UqudoSDK', '2.2.1'
+  s.dependency 'OpenSSL-Universal', '1.1.1700'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/android/build.gradle

@@ -0,0 +1,65 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.1'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.2.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.2'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.3.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.2.1'
+    }
+}
+
+rootProject.allprojects {
+    repositories {
+        google()
+        maven { url "https://rm.dev.uqudo.io/repository/uqudo-public/" }
+    }
+}
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 30
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 21
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 30
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "io.uqudo.sdk:Uqudo:2.2.1"
+
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.uqudo.sdk.id.capacitor">
+</manifest>

package/android/src/main/java/io/uqudo/sdk/id/capacitor/UqudoIdPlugin.java

@@ -0,0 +1,375 @@
+package io.uqudo.sdk.id.capacitor;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+
+import androidx.activity.result.ActivityResult;
+import androidx.appcompat.app.AppCompatDelegate;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.ActivityCallback;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import org.jetbrains.annotations.NotNull;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.util.UUID;
+
+import io.uqudo.sdk.core.DocumentBuilder;
+import io.uqudo.sdk.core.SessionStatus;
+import io.uqudo.sdk.core.SessionStatusCode;
+import io.uqudo.sdk.core.UqudoBuilder;
+import io.uqudo.sdk.core.UqudoSDK;
+import io.uqudo.sdk.core.analytics.Trace;
+import io.uqudo.sdk.core.analytics.Tracer;
+import io.uqudo.sdk.core.builder.BackgroundCheckConfigurationBuilder;
+import io.uqudo.sdk.core.builder.FacialRecognitionConfigurationBuilder;
+import io.uqudo.sdk.core.builder.ReadingConfigurationBuilder;
+import io.uqudo.sdk.core.domain.model.BackgroundCheckType;
+import io.uqudo.sdk.core.domain.model.Document;
+import io.uqudo.sdk.core.domain.model.DocumentType;
+
+@CapacitorPlugin(name = "UqudoId")
+public class UqudoIdPlugin extends Plugin {
+
+    @PluginMethod
+    public void init(PluginCall call) {
+        UqudoSDK.init(getContext(), new TraceObject());
+        call.resolve(new JSObject());
+    }
+
+    private class TraceObject implements Tracer {
+        @Override
+        public void trace(@NotNull Trace trace) {
+            try {
+                JSONObject json = new JSONObject();
+                json.put("category", trace.getCategory());
+                json.put("sessionId", trace.getSessionId());
+                json.put("event", trace.getEvent());
+                json.put("page", trace.getPage());
+                json.put("statusCode", trace.getStatusCode());
+                json.put("status", trace.getStatus());
+                json.put("statusMessage", trace.getStatusMessage());
+                json.put("timestamp", trace.getTimestamp());
+                json.put("documentType", trace.getDocumentType());
+                String data = json.toString();
+                bridge.triggerWindowJSEvent("TraceEvent", data);
+            } catch (Exception e) {
+                Log.e("UqudoIdPlugin", e.getMessage(), e);
+            }
+        }
+    }
+
+    @PluginMethod
+    public void setLocale(PluginCall call) {
+        String locale = call.getString("value");
+        if (locale != null) {
+            UqudoSDK.setLocale(getContext(), locale);
+        }
+        call.resolve(new JSObject());
+    }
+
+    @PluginMethod
+    public void enroll(PluginCall call) {
+        String message = call.getString("value");
+        if (message != null && message.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(message);
+                UqudoBuilder.Enrollment enrollment = new UqudoBuilder.Enrollment();
+                if (json.has("isSecuredWindowsDisabled") && json.getBoolean("isSecuredWindowsDisabled")) {
+                    enrollment.disableSecureWindow();
+                }
+                if (json.has("isRootedDeviceAllowed") && json.getBoolean("isRootedDeviceAllowed")) {
+                    enrollment.enableRootedDeviceUsage();
+                }
+                if (json.has("nonce")) {
+                    enrollment.setNonce(json.getString("nonce"));
+                }
+                if (json.has("sessionId")) {
+                    enrollment.setSessionId(json.getString("sessionId"));
+                }
+                if (json.has("userIdentifier")) {
+                    enrollment.setUserIdentifier(UUID.fromString(json.getString("userIdentifier")));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    enrollment.returnDataForIncompleteSession();
+                }
+                if (json.has("facialRecognitionSpecification")) {
+                    FacialRecognitionConfigurationBuilder faceBuilder = new FacialRecognitionConfigurationBuilder();
+                    JSONObject faceObject = json.getJSONObject("facialRecognitionSpecification");
+                    if (faceObject.has("enrollFace") && faceObject.getBoolean("enrollFace")) {
+                        faceBuilder.enrollFace();
+                    }
+                    if (faceObject.has("scanMinimumMatchLevel") && faceObject.getInt("scanMinimumMatchLevel") > 0) {
+                        faceBuilder.setScanMinimumMatchLevel(faceObject.getInt("scanMinimumMatchLevel"));
+                    }
+                    if (faceObject.has("readMinimumMatchLevel") && faceObject.getInt("readMinimumMatchLevel") > 0) {
+                        faceBuilder.setReadMinimumMatchLevel(faceObject.getInt("readMinimumMatchLevel"));
+                    }
+                    if (faceObject.has("maxAttempts") && faceObject.getInt("maxAttempts") > 0) {
+                        faceBuilder.setMaxAttempts(faceObject.getInt("maxAttempts"));
+                    }
+                    enrollment.enableFacialRecognition(faceBuilder.build());
+                }
+
+                if (json.has("lookupConfiguration")) {
+                     JSONObject lookupObject = json.getJSONObject("lookupConfiguration");
+                     if (lookupObject.has("documentList")) {
+                         JSONArray lookupDocuments = lookupObject.getJSONArray("documentList");
+                         if (lookupDocuments.length() > 0) {
+                             DocumentType[] documents = new DocumentType[lookupDocuments.length()];
+                             for (int i = 0; i < lookupDocuments.length(); i++) {
+                                 String parsedDocument = lookupDocuments.getString(i);
+                                 documents[i] = DocumentType.valueOf(parsedDocument);
+                             }
+                             enrollment.enableLookup(documents);
+                         } else {
+                             enrollment.enableLookup();
+                         }
+                     } else {
+                         enrollment.enableLookup();
+                     }
+                }
+
+                if (json.has("backgroundCheckConfiguration")) {
+                    BackgroundCheckConfigurationBuilder backgroundCheckConfigurationBuilder = new BackgroundCheckConfigurationBuilder();
+                    JSONObject backgroundObject = json.getJSONObject("backgroundCheckConfiguration");
+                    if (backgroundObject.has("disableConsent") && backgroundObject.getBoolean("disableConsent")) {
+                        backgroundCheckConfigurationBuilder.disableConsent();
+                    }
+                    if (backgroundObject.has("backgroundCheckType")) {
+                        backgroundCheckConfigurationBuilder.setBackgroundCheckType(BackgroundCheckType.valueOf(backgroundObject.getString("backgroundCheckType")));
+                    }
+                    if (backgroundObject.has("monitoringEnabled") && backgroundObject.getBoolean("monitoringEnabled")) {
+                        backgroundCheckConfigurationBuilder.enableMonitoring();
+                    }
+                    if (backgroundObject.has("skipView") && backgroundObject.getBoolean("skipView")) {
+                        backgroundCheckConfigurationBuilder.skipView();
+                    }
+                    enrollment.enableBackgroundCheck(backgroundCheckConfigurationBuilder.build());
+                }
+                enrollment.setToken(json.getString("authorizationToken"));
+                JSONArray documentList = json.getJSONArray("documentList");
+                for (int i = 0; i < documentList.length(); i++) {
+                    JSONObject documentJson = documentList.getJSONObject(i);
+                    DocumentBuilder documentBuilder = new DocumentBuilder(getContext());
+                    documentBuilder.setDocumentType(DocumentType.valueOf(documentJson.getString("documentType")));
+                    if (documentJson.has("isHelpPageDisabled") && documentJson.getBoolean("isHelpPageDisabled")) {
+                        documentBuilder.disableHelpPage();
+                    }
+                    if (documentJson.has("isExpiredDocumentValidateDisabled") && documentJson.getBoolean("isExpiredDocumentValidateDisabled")) {
+                        documentBuilder.disableExpiryValidation();
+                    }
+                    if (documentJson.has("isFrontSideReviewEnabled") || documentJson.has("isBackSideReviewEnabled")) {
+                        documentBuilder.enableScanReview(documentJson.optBoolean("isFrontSideReviewEnabled", false), documentJson.optBoolean("isBackSideReviewEnabled", false));
+                    }
+                    if (documentJson.has("isUploadEnabled") && documentJson.getBoolean("isUploadEnabled")) {
+                        documentBuilder.enableUpload();
+                    }
+                    if (documentJson.has("minimumAge") && documentJson.getInt("minimumAge") > 0) {
+                        documentBuilder.enableAgeVerification(documentJson.getInt("minimumAge"));
+                    }
+
+                    if (documentJson.has("readingConfiguration")) {
+                        JSONObject readConfiguration = documentJson.getJSONObject("readingConfiguration");
+                        if (readConfiguration.has("forceReading")) {
+                            ReadingConfigurationBuilder readingConfigurationBuilder = new ReadingConfigurationBuilder();
+                            if (readConfiguration.has("forceReading")) {
+                                readingConfigurationBuilder.forceReading(readConfiguration.getBoolean("forceReading"));
+                            }
+                            if (readConfiguration.has("forceReadingIfSupported")) {
+                                readingConfigurationBuilder.forceReadingIfSupported(readConfiguration.getBoolean("forceReadingIfSupported"));
+                            }
+
+                            if (readConfiguration.has("timeoutInSeconds")) {
+                                readingConfigurationBuilder.forceReadingTimeout(readConfiguration.getInt("timeoutInSeconds"));
+                            }
+
+
+                            documentBuilder.enableReading(readingConfigurationBuilder.build());
+                        } else {
+                            documentBuilder.enableReading();
+                        }
+                    }
+                    if (documentJson.has("faceScanMinimumMatchLevel") && documentJson.getInt("faceScanMinimumMatchLevel") > 0) {
+                        documentBuilder.setFaceScanMinimumMatchLevel(documentJson.getInt("faceScanMinimumMatchLevel"));
+                    }
+                    if (documentJson.has("faceReadMinimumMatchLevel") && documentJson.getInt("faceReadMinimumMatchLevel") > 0) {
+                        documentBuilder.setFaceReadMinimumMatchLevel(documentJson.getInt("faceReadMinimumMatchLevel"));
+                    }
+
+
+                    Document document = documentBuilder.build();
+                    enrollment.add(document);
+                }
+                if (json.has("appearanceMode")) {
+                    if ("LIGHT".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                    } else if ("DARK".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                    } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                    }
+                }else{
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                }
+                call.setKeepAlive(true);
+                Intent intent = enrollment.build(getContext());
+
+                startActivityForResult(call, intent, "handleActivityResult");
+            } catch (Exception e) {
+                Log.d("UqudoPlugin", e.getMessage(), e);
+                sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), e.getMessage(), null);
+            }
+        } else {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected enrollment object as argument.", null);
+        }
+    }
+
+    @PluginMethod
+    public void recover(PluginCall call) {
+        String message = call.getString("value");
+        if (message != null && message.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(message);
+                UqudoBuilder.AccountRecovery recovery = new UqudoBuilder.AccountRecovery();
+                recovery.setToken(json.getString("token"));
+                recovery.setEnrollmentIdentifier(json.getString("enrollmentIdentifier"));
+                if (json.has("nonce")) {
+                    recovery.setNonce(json.getString("nonce"));
+                }
+                if (json.has("isRootedDeviceAllowed")) {
+                    recovery.enableRootedDeviceUsage();
+                }
+                if (json.has("isSecuredWindowsDisabled")) {
+                    recovery.disableSecureWindow();
+                }
+                if (json.has("minimumMatchLevel") && json.getInt("minimumMatchLevel") > 0) {
+                    recovery.setMinimumMatchLevel(json.getInt("minimumMatchLevel"));
+                }
+                if (json.has("maxAttempts") && json.getInt("maxAttempts") > 0) {
+                    recovery.setMaxAttempts(json.getInt("maxAttempts"));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    recovery.returnDataForIncompleteSession();
+                }
+                if (json.has("appearanceMode")) {
+                                    if ("LIGHT".equals(json.getString("appearanceMode"))) {
+                                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                                    } else if ("DARK".equals(json.getString("appearanceMode"))) {
+                                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                                    } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
+                                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                                    }
+                                }else{
+                                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                }
+                call.setKeepAlive(true);
+                Intent intent = recovery.build(getContext());
+                startActivityForResult(call, intent, "handleActivityResult");
+            } catch (Exception e) {
+                Log.d("UqudoPlugin", e.getMessage(), e);
+                sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), e.getMessage(), null);
+            }
+        } else {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected account recovery object as argument.", null);
+        }
+    }
+
+
+    @PluginMethod
+    public void faceSession(PluginCall call) {
+        String message = call.getString("value");
+        if (message != null && message.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(message);
+                UqudoBuilder.FaceSession faceSessionBuilder = new UqudoBuilder.FaceSession();
+                faceSessionBuilder.setToken(json.getString("token"));
+                faceSessionBuilder.setSessionId(json.getString("sessionId"));
+                if (json.has("nonce")) {
+                    faceSessionBuilder.setNonce(json.getString("nonce"));
+                }
+                if (json.has("isRootedDeviceAllowed")) {
+                    faceSessionBuilder.enableRootedDeviceUsage();
+                }
+                if (json.has("isSecuredWindowsDisabled")) {
+                    faceSessionBuilder.disableSecureWindow();
+                }
+                if (json.has("minimumMatchLevel") && json.getInt("minimumMatchLevel") > 0) {
+                    faceSessionBuilder.setMinimumMatchLevel(json.getInt("minimumMatchLevel"));
+                }
+                if (json.has("maxAttempts") && json.getInt("maxAttempts") > 0) {
+                    faceSessionBuilder.setMaxAttempts(json.getInt("maxAttempts"));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    faceSessionBuilder.returnDataForIncompleteSession();
+                }
+                if (json.has("appearanceMode")) {
+                    if ("LIGHT".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                    } else if ("DARK".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                    } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
+                        AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                    }
+                }else{
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                }
+                call.setKeepAlive(true);
+                Intent intent = faceSessionBuilder.build(getContext());
+                startActivityForResult(call, intent, "handleActivityResult");
+            } catch (Exception e) {
+                Log.d("UqudoPlugin", e.getMessage(), e);
+                sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), e.getMessage(), null);
+            }
+        } else {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected face session object as argument.", null);
+        }
+    }
+
+    private void sendError(PluginCall call, String code, String message, String task) {
+        sendError(call, code, message, task, null);
+    }
+
+    private void sendError(PluginCall call, String code, String message, String task, String data) {
+        JSONObject error = new JSONObject();
+        try {
+            error.put("code", code);
+            error.put("message", message);
+            error.put("task", task);
+            error.put("data", data);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        call.reject(error.toString(),"");
+    }
+
+    @ActivityCallback
+    protected void handleActivityResult(PluginCall savedCall, ActivityResult result) {
+        if (savedCall == null) {
+            Log.d("UqudoPlugin", "saved call is null");
+            return;
+        }
+
+        if (result.getResultCode() == Activity.RESULT_OK) {
+            try {
+                String response;
+                response = new JSONObject().put("value", result.getData().getStringExtra("data")).toString();
+                savedCall.resolve(new JSObject(response));
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        } else if (result.getResultCode() == Activity.RESULT_CANCELED) {
+            if (result.getData() != null) {
+                SessionStatus sessionStatus = result.getData().getParcelableExtra("key_session_status");
+                assert sessionStatus != null;
+                sendError(savedCall, sessionStatus.getSessionStatusCode().name(), sessionStatus.getSessionStatusCode().getMessage(), sessionStatus.getSessionTask().name(), sessionStatus.getData());
+            }
+        }
+    }
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,21 @@
+export interface UqudoIdPlugin {
+    init(): void;
+    setLocale(options: {
+        value: String;
+    }): void;
+    enroll(options: {
+        value: string;
+    }): Promise<{
+        value: string;
+    }>;
+    recover(options: {
+        value: string;
+    }): Promise<{
+        value: string;
+    }>;
+    faceSession(options: {
+        value: string;
+    }): Promise<{
+        value: string;
+    }>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":""}