uqudosdk-capacitor 2.5.4 → 2.6.0

package/UqudosdkCapacitor.podspec

@@ -12,7 +12,7 @@ Pod::Spec.new do |s|
   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.5.4'
+  s.dependency 'UqudoSDK', '2.6.0'
   s.dependency 'OpenSSL-Universal', '1.1.1700'
   s.dependency 'Capacitor'
   s.swift_version = '5.1'

package/android/build.gradle

@@ -56,7 +56,7 @@ repositories {
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation project(':capacitor-android')
-    implementation "io.uqudo.sdk:Uqudo:2.5.4"
+    implementation "io.uqudo.sdk:Uqudo:2.6.0"
 
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
     testImplementation "junit:junit:$junitVersion"

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

@@ -34,6 +34,9 @@ import io.uqudo.sdk.core.domain.model.BackgroundCheckType;
 import io.uqudo.sdk.core.domain.model.Document;
 import io.uqudo.sdk.core.domain.model.DocumentType;
 
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+
 @CapacitorPlugin(name = "UqudoId")
 public class UqudoIdPlugin extends Plugin {
 
@@ -55,7 +58,9 @@ public class UqudoIdPlugin extends Plugin {
                 json.put("statusCode", trace.getStatusCode());
                 json.put("status", trace.getStatus());
                 json.put("statusMessage", trace.getStatusMessage());
-                json.put("timestamp", trace.getTimestamp());
+                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
+                dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+                json.put("timestamp", dateFormat.format(trace.getTimestamp()));
                 json.put("documentType", trace.getDocumentType());
                 String data = json.toString();
                 bridge.triggerWindowJSEvent("TraceEvent", data);
@@ -84,9 +89,6 @@ public class UqudoIdPlugin extends Plugin {
                 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"));
                 }
@@ -118,22 +120,22 @@ public class UqudoIdPlugin extends Plugin {
                 }
 
                 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();
-                     }
+                    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")) {
@@ -215,7 +217,7 @@ public class UqudoIdPlugin extends Plugin {
                     } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
                         AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
                     }
-                }else{
+                } else {
                     AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
                 }
                 call.setKeepAlive(true);
@@ -243,10 +245,7 @@ public class UqudoIdPlugin extends Plugin {
                 if (json.has("nonce")) {
                     recovery.setNonce(json.getString("nonce"));
                 }
-                if (json.has("isRootedDeviceAllowed")) {
-                    recovery.enableRootedDeviceUsage();
-                }
-                if (json.has("isSecuredWindowsDisabled")) {
+                if (json.has("isSecuredWindowsDisabled") && json.getBoolean("isSecuredWindowsDisabled")) {
                     recovery.disableSecureWindow();
                 }
                 if (json.has("minimumMatchLevel") && json.getInt("minimumMatchLevel") > 0) {
@@ -259,15 +258,15 @@ public class UqudoIdPlugin extends Plugin {
                     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);
+                    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());
@@ -294,10 +293,7 @@ public class UqudoIdPlugin extends Plugin {
                 if (json.has("nonce")) {
                     faceSessionBuilder.setNonce(json.getString("nonce"));
                 }
-                if (json.has("isRootedDeviceAllowed")) {
-                    faceSessionBuilder.enableRootedDeviceUsage();
-                }
-                if (json.has("isSecuredWindowsDisabled")) {
+                if (json.has("isSecuredWindowsDisabled") && json.getBoolean("isSecuredWindowsDisabled")) {
                     faceSessionBuilder.disableSecureWindow();
                 }
                 if (json.has("minimumMatchLevel") && json.getInt("minimumMatchLevel") > 0) {
@@ -317,7 +313,7 @@ public class UqudoIdPlugin extends Plugin {
                     } else if ("SYSTEM".equals(json.getString("appearanceMode"))) {
                         AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
                     }
-                }else{
+                } else {
                     AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
                 }
                 call.setKeepAlive(true);
@@ -333,32 +329,153 @@ public class UqudoIdPlugin extends Plugin {
     }
 
     @PluginMethod
-     public void isReadingSupported(PluginCall call) {
-        try {
-                String documentType = call.getString("value");
-                if (documentType != null) {
-                  JSObject ret = new JSObject();
-                  ret.put("value", DocumentType.valueOf(documentType).getReadingSupported());
-                  call.resolve(ret);
+    public void lookup(PluginCall call) {
+        String message = call.getString("value");
+        if (message != null && message.length() > 0) {
+            try {
+                JSONObject json = new JSONObject(message);
+                UqudoBuilder.Lookup lookup = new UqudoBuilder.Lookup();
+                if (json.has("isSecuredWindowsDisabled") && json.getBoolean("isSecuredWindowsDisabled")) {
+                    lookup.disableSecureWindow();
+                }
+                if (json.has("nonce")) {
+                    lookup.setNonce(json.getString("nonce"));
+                }
+                if (json.has("sessionId")) {
+                    lookup.setSessionId(json.getString("sessionId"));
+                }
+                if (json.has("userIdentifier")) {
+                    lookup.setUserIdentifier(UUID.fromString(json.getString("userIdentifier")));
+                }
+                if (json.has("isReturnDataForIncompleteSession") && json.getBoolean("isReturnDataForIncompleteSession")) {
+                    lookup.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("lookupMinimumMatchLevel") && faceObject.getInt("lookupMinimumMatchLevel") > 0) {
+                        faceBuilder.setLookupMinimumMatchLevel(faceObject.getInt("lookupMinimumMatchLevel"));
+                    }
+                    if (faceObject.has("maxAttempts") && faceObject.getInt("maxAttempts") > 0) {
+                        faceBuilder.setMaxAttempts(faceObject.getInt("maxAttempts"));
+                    }
+                    lookup.enableFacialRecognition(faceBuilder.build());
+                }
+                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();
+                    }
+                    lookup.enableBackgroundCheck(backgroundCheckConfigurationBuilder.build());
                 }
-             } catch (Exception e) {
-                sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected document type as argument.", null);
-             }
-     }
+                lookup.setToken(json.getString("authorizationToken"));
+                lookup.setDocumentType(DocumentType.valueOf(json.getString("documentType")));
+                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 = lookup.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 isFacialRecognitionSupported(PluginCall call) {
-         try {
-                String documentType = call.getString("value");
-                if (documentType != null) {
-                  JSObject ret = new JSObject();
-                  ret.put("value", DocumentType.valueOf(documentType).getFacialRecognitionSupported());
-                  call.resolve(ret);
-                }
-             } catch (Exception e) {
-                sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected document type as argument.", null);
-             }
-     }
+    public void isReadingSupported(PluginCall call) {
+        try {
+            String documentType = call.getString("value");
+            if (documentType != null) {
+                JSObject ret = new JSObject();
+                ret.put("value", DocumentType.valueOf(documentType).getReadingSupported());
+                call.resolve(ret);
+            }
+        } catch (Exception e) {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected valid document type as argument", null);
+        }
+    }
+
+    @PluginMethod
+    public void isFacialRecognitionSupported(PluginCall call) {
+        try {
+            String documentType = call.getString("value");
+            if (documentType != null) {
+                JSObject ret = new JSObject();
+                ret.put("value", DocumentType.valueOf(documentType).getFacialRecognitionSupported());
+                call.resolve(ret);
+            }
+        } catch (Exception e) {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected valid document type as argument", null);
+        }
+    }
+
+    @PluginMethod
+    public void isLookupSupported(PluginCall call) {
+        try {
+            String documentType = call.getString("value");
+            if (documentType != null) {
+                JSObject ret = new JSObject();
+                ret.put("value", DocumentType.valueOf(documentType).getLookupSupported());
+                call.resolve(ret);
+            }
+        } catch (Exception e) {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected valid document type as argument", null);
+        }
+    }
+
+    @PluginMethod
+    public void isLookupFacialRecognitionSupported(PluginCall call) {
+        try {
+            String documentType = call.getString("value");
+            if (documentType != null) {
+                JSObject ret = new JSObject();
+                ret.put("value", DocumentType.valueOf(documentType).getLookupFacialRecognitionSupported());
+                call.resolve(ret);
+            }
+        } catch (Exception e) {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected valid document type as argument", null);
+        }
+    }
+
+    @PluginMethod
+    public void isEnrollmentSupported(PluginCall call) {
+        try {
+            String documentType = call.getString("value");
+            if (documentType != null) {
+                JSObject ret = new JSObject();
+                ret.put("value", DocumentType.valueOf(documentType).getEnrollmentSupported());
+                call.resolve(ret);
+            }
+        } catch (Exception e) {
+            sendError(call, SessionStatusCode.UNEXPECTED_ERROR.name(), "Expected valid document type as argument", null);
+        }
+    }
 
     private void sendError(PluginCall call, String code, String message, String task) {
         sendError(call, code, message, task, null);
@@ -374,7 +491,7 @@ public class UqudoIdPlugin extends Plugin {
         } catch (Exception e) {
             e.printStackTrace();
         }
-        call.reject(error.toString(),"");
+        call.reject("", error.toString());
     }
 
     @ActivityCallback

package/dist/esm/definitions.d.ts

@@ -18,6 +18,11 @@ export interface UqudoIdPlugin {
     }): Promise<{
         value: string;
     }>;
+    lookup(options: {
+        value: string;
+    }): Promise<{
+        value: string;
+    }>;
     isFacialRecognitionSupported(options: {
         value: string;
     }): Promise<{
@@ -28,4 +33,19 @@ export interface UqudoIdPlugin {
     }): Promise<{
         value: boolean;
     }>;
+    isLookupSupported(options: {
+        value: string;
+    }): Promise<{
+        value: boolean;
+    }>;
+    isLookupFacialRecognitionSupported(options: {
+        value: string;
+    }): Promise<{
+        value: boolean;
+    }>;
+    isEnrollmentSupported(options: {
+        value: string;
+    }): Promise<{
+        value: boolean;
+    }>;
 }

package/dist/esm/index.d.ts

@@ -21,7 +21,7 @@ export declare class EnrollmentBuilder {
     setUserIdentifier(userIdentifier: string): EnrollmentBuilder;
     enableRootedDeviceUsage(): EnrollmentBuilder;
     disableSecureWindow(): EnrollmentBuilder;
-    enableFacialRecognition(facialRecognitionConfigurationBuilder?: FacialRecognitionConfiguration): EnrollmentBuilder;
+    enableFacialRecognition(facialRecognitionConfiguration?: FacialRecognitionConfiguration): EnrollmentBuilder;
     enableBackgroundCheck(backgroundCheckConfiguration: BackgroundCheckConfiguration): EnrollmentBuilder;
     returnDataForIncompleteSession(): EnrollmentBuilder;
     enableLookup(documents?: DocumentType[]): EnrollmentBuilder;
@@ -49,11 +49,13 @@ export declare class FacialRecognitionConfigurationBuilder {
     private isEnrollFace?;
     private scanMinimumMatchLevel?;
     private readMinimumMatchLevel?;
+    private lookupMinimumMatchLevel?;
     private maxAttempts?;
     disableHelpPage(): FacialRecognitionConfigurationBuilder;
     enrollFace(): FacialRecognitionConfigurationBuilder;
     setScanMinimumMatchLevel(scanMinimumMatchLevel: number): FacialRecognitionConfigurationBuilder;
     setReadMinimumMatchLevel(readMinimumMatchLevel: number): FacialRecognitionConfigurationBuilder;
+    setLookupMinimumMatchLevel(lookupMinimumMatchLevel: number): FacialRecognitionConfigurationBuilder;
     setMaxAttempts(maxAttempts: number): FacialRecognitionConfigurationBuilder;
     build(): FacialRecognitionConfiguration;
 }
@@ -62,8 +64,9 @@ export declare class FacialRecognitionConfiguration {
     private enrollFace?;
     private scanMinimumMatchLevel?;
     private readMinimumMatchLevel?;
+    private lookupMinimumMatchLevel?;
     private maxAttempts?;
-    constructor(isHelpPageDisabled?: boolean, enrollFace?: boolean, scanMinimumMatchLevel?: number, readMinimumMatchLevel?: number, maxAttempts?: number);
+    constructor(isHelpPageDisabled?: boolean, enrollFace?: boolean, scanMinimumMatchLevel?: number, readMinimumMatchLevel?: number, lookupMinimumMatchLevel?: number, maxAttempts?: number);
 }
 export declare class BackgroundCheckConfigurationBuilder {
     private isDisableConsent?;
@@ -143,6 +146,7 @@ export declare class ReadingConfigurationBuilder {
     forceReadingTimeout(value: number): ReadingConfigurationBuilder;
     build(): ReadingConfiguration;
 }
+export { AccountRecoveryConfigurationBuilder as AccountRecoveryBuilder };
 export declare class AccountRecoveryConfigurationBuilder {
     private authorizationToken?;
     private enrollmentIdentifier?;
@@ -199,6 +203,7 @@ export declare class AccountRecoveryConfiguration {
     private appearanceMode?;
     constructor(token?: string, enrollmentIdentifier?: string, nonce?: string, isRootedDeviceAllowed?: boolean, isSecuredWindowsDisabled?: boolean, minimumMatchLevel?: number, maxAttempts?: number, isReturnDataForIncompleteSession?: boolean, appearanceMode?: AppearanceMode);
 }
+export { FaceSessionConfigurationBuilder as FaceSessionBuilder };
 export declare class FaceSessionConfigurationBuilder {
     private authorizationToken?;
     private sessionId?;
@@ -255,6 +260,42 @@ export declare class FaceSessionConfiguration {
     private appearanceMode?;
     constructor(token?: string, sessionId?: string, nonce?: string, isRootedDeviceAllowed?: boolean, isSecuredWindowsDisabled?: boolean, minimumMatchLevel?: number, maxAttempts?: number, isReturnDataForIncompleteSession?: boolean, appearanceMode?: AppearanceMode);
 }
+export declare class LookupBuilder {
+    private documentType?;
+    private authorizationToken?;
+    private nonce?;
+    private isSecuredWindowsDisabled?;
+    private facialRecognitionSpecification?;
+    private backgroundCheckConfiguration?;
+    private sessionId?;
+    private userIdentifier?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode;
+    setToken(token: string): LookupBuilder;
+    setNonce(nonce: string): LookupBuilder;
+    setSessionId(sessionId: string): LookupBuilder;
+    setUserIdentifier(userIdentifier: string): LookupBuilder;
+    disableSecureWindow(): LookupBuilder;
+    enableFacialRecognition(facialRecognitionConfiguration?: FacialRecognitionConfiguration): LookupBuilder;
+    enableBackgroundCheck(backgroundCheckConfiguration: BackgroundCheckConfiguration): LookupBuilder;
+    returnDataForIncompleteSession(): LookupBuilder;
+    setDocumentType(documentType: DocumentType): LookupBuilder;
+    setAppearanceMode(appearanceMode: AppearanceMode): LookupBuilder;
+    build(): Lookup;
+}
+export declare class Lookup {
+    private documentType?;
+    private authorizationToken?;
+    private nonce?;
+    private isSecuredWindowsDisabled?;
+    private facialRecognitionSpecification?;
+    private backgroundCheckConfiguration?;
+    private sessionId?;
+    private userIdentifier?;
+    private isReturnDataForIncompleteSession?;
+    private appearanceMode?;
+    constructor(documentType?: DocumentType, authorizationToken?: string, nonce?: string, isSecuredWindowsDisabled?: boolean, facialRecognitionSpecification?: FacialRecognitionConfiguration, backgroundCheckConfiguration?: BackgroundCheckConfiguration, sessionId?: string, userIdentifier?: string, isReturnDataForIncompleteSession?: boolean, appearanceMode?: AppearanceMode);
+}
 export declare enum DocumentType {
     BHR_ID = "BHR_ID",
     GENERIC_ID = "GENERIC_ID",
@@ -307,7 +348,8 @@ export declare enum DocumentType {
     RSL_ID = "RSL_ID",
     IND_PAN = "IND_PAN",
     SAU_ID_NATIONAL = "SAU_ID_NATIONAL",
-    SAU_ID_RESIDENT = "SAU_ID_RESIDENT"
+    SAU_ID_RESIDENT = "SAU_ID_RESIDENT",
+    NGA_BVN = "NGA_BVN"
 }
 export declare enum BackgroundCheckType {
     RDC = "RDC",
@@ -330,6 +372,12 @@ export declare class UqudoPlugin {
     faceSession(faceSessionObj: FaceSessionConfiguration): Promise<{
         value: string;
     }>;
+    lookup(lookup: Lookup): Promise<{
+        value: string;
+    }>;
     isFacialRecognitionSupported(documentType: string): Promise<boolean>;
     isReadingSupported(documentType: string): Promise<boolean>;
+    isLookupSupported(documentType: string): Promise<boolean>;
+    isLookupFacialRecognitionSupported(documentType: string): Promise<boolean>;
+    isEnrollmentSupported(documentType: string): Promise<boolean>;
 }

package/dist/esm/index.js

@@ -31,12 +31,12 @@ export class EnrollmentBuilder {
         this.isSecuredWindowsDisabled = true;
         return this;
     }
-    enableFacialRecognition(facialRecognitionConfigurationBuilder) {
-        if (facialRecognitionConfigurationBuilder === null) {
+    enableFacialRecognition(facialRecognitionConfiguration) {
+        if (facialRecognitionConfiguration === undefined) {
             this.facialRecognitionSpecification = new FacialRecognitionConfigurationBuilder().build();
         }
         else {
-            this.facialRecognitionSpecification = facialRecognitionConfigurationBuilder;
+            this.facialRecognitionSpecification = facialRecognitionConfiguration;
         }
         return this;
     }
@@ -102,20 +102,25 @@ export class FacialRecognitionConfigurationBuilder {
         this.readMinimumMatchLevel = readMinimumMatchLevel;
         return this;
     }
+    setLookupMinimumMatchLevel(lookupMinimumMatchLevel) {
+        this.lookupMinimumMatchLevel = lookupMinimumMatchLevel;
+        return this;
+    }
     setMaxAttempts(maxAttempts) {
         this.maxAttempts = maxAttempts;
         return this;
     }
     build() {
-        return new FacialRecognitionConfiguration(this.isHelpPageDisabled, this.isEnrollFace, this.scanMinimumMatchLevel, this.readMinimumMatchLevel, this.maxAttempts);
+        return new FacialRecognitionConfiguration(this.isHelpPageDisabled, this.isEnrollFace, this.scanMinimumMatchLevel, this.readMinimumMatchLevel, this.lookupMinimumMatchLevel, this.maxAttempts);
     }
 }
 export class FacialRecognitionConfiguration {
-    constructor(isHelpPageDisabled, enrollFace, scanMinimumMatchLevel, readMinimumMatchLevel, maxAttempts) {
+    constructor(isHelpPageDisabled, enrollFace, scanMinimumMatchLevel, readMinimumMatchLevel, lookupMinimumMatchLevel, maxAttempts) {
         this.isHelpPageDisabled = isHelpPageDisabled;
         this.enrollFace = enrollFace;
         this.scanMinimumMatchLevel = scanMinimumMatchLevel;
         this.readMinimumMatchLevel = readMinimumMatchLevel;
+        this.lookupMinimumMatchLevel = lookupMinimumMatchLevel;
         this.maxAttempts = maxAttempts;
     }
 }
@@ -249,6 +254,7 @@ export class ReadingConfigurationBuilder {
         return new ReadingConfiguration(this.forceReadingValue, this.forceReadingIfSupportedValue, this.timeoutInSeconds);
     }
 }
+export { AccountRecoveryConfigurationBuilder as AccountRecoveryBuilder };
 export class AccountRecoveryConfigurationBuilder {
     constructor() {
         this.appearanceMode = AppearanceMode.SYSTEM;
@@ -330,7 +336,7 @@ export class AccountRecoveryConfiguration {
         this.appearanceMode = appearanceMode;
     }
 }
-///
+export { FaceSessionConfigurationBuilder as FaceSessionBuilder };
 export class FaceSessionConfigurationBuilder {
     constructor() {
         this.appearanceMode = AppearanceMode.SYSTEM;
@@ -412,6 +418,73 @@ export class FaceSessionConfiguration {
         this.appearanceMode = appearanceMode;
     }
 }
+export class LookupBuilder {
+    constructor() {
+        this.appearanceMode = AppearanceMode.SYSTEM;
+    }
+    setToken(token) {
+        this.authorizationToken = token;
+        return this;
+    }
+    setNonce(nonce) {
+        this.nonce = nonce;
+        return this;
+    }
+    setSessionId(sessionId) {
+        this.sessionId = sessionId;
+        return this;
+    }
+    setUserIdentifier(userIdentifier) {
+        this.userIdentifier = userIdentifier;
+        return this;
+    }
+    disableSecureWindow() {
+        this.isSecuredWindowsDisabled = true;
+        return this;
+    }
+    enableFacialRecognition(facialRecognitionConfiguration) {
+        if (facialRecognitionConfiguration === undefined) {
+            this.facialRecognitionSpecification = new FacialRecognitionConfigurationBuilder().build();
+        }
+        else {
+            this.facialRecognitionSpecification = facialRecognitionConfiguration;
+        }
+        return this;
+    }
+    enableBackgroundCheck(backgroundCheckConfiguration) {
+        this.backgroundCheckConfiguration = backgroundCheckConfiguration;
+        return this;
+    }
+    returnDataForIncompleteSession() {
+        this.isReturnDataForIncompleteSession = true;
+        return this;
+    }
+    setDocumentType(documentType) {
+        this.documentType = documentType;
+        return this;
+    }
+    setAppearanceMode(appearanceMode) {
+        this.appearanceMode = appearanceMode;
+        return this;
+    }
+    build() {
+        return new Lookup(this.documentType, this.authorizationToken, this.nonce, this.isSecuredWindowsDisabled, this.facialRecognitionSpecification, this.backgroundCheckConfiguration, this.sessionId, this.userIdentifier, this.isReturnDataForIncompleteSession, this.appearanceMode);
+    }
+}
+export class Lookup {
+    constructor(documentType, authorizationToken, nonce, isSecuredWindowsDisabled, facialRecognitionSpecification, backgroundCheckConfiguration, sessionId, userIdentifier, isReturnDataForIncompleteSession, appearanceMode) {
+        this.documentType = documentType;
+        this.authorizationToken = authorizationToken;
+        this.nonce = nonce;
+        this.isSecuredWindowsDisabled = isSecuredWindowsDisabled;
+        this.facialRecognitionSpecification = facialRecognitionSpecification;
+        this.backgroundCheckConfiguration = backgroundCheckConfiguration;
+        this.sessionId = sessionId;
+        this.userIdentifier = userIdentifier;
+        this.isReturnDataForIncompleteSession = isReturnDataForIncompleteSession;
+        this.appearanceMode = appearanceMode;
+    }
+}
 export var DocumentType;
 (function (DocumentType) {
     DocumentType["BHR_ID"] = "BHR_ID";
@@ -466,6 +539,7 @@ export var DocumentType;
     DocumentType["IND_PAN"] = "IND_PAN";
     DocumentType["SAU_ID_NATIONAL"] = "SAU_ID_NATIONAL";
     DocumentType["SAU_ID_RESIDENT"] = "SAU_ID_RESIDENT";
+    DocumentType["NGA_BVN"] = "NGA_BVN";
 })(DocumentType || (DocumentType = {}));
 export var BackgroundCheckType;
 (function (BackgroundCheckType) {
@@ -500,6 +574,11 @@ export class UqudoPlugin {
         const response = await UqudoId.faceSession({ value: faceSession });
         return response;
     }
+    async lookup(lookup) {
+        const lookupSession = JSON.stringify(lookup);
+        const response = await UqudoId.lookup({ value: lookupSession });
+        return response;
+    }
     async isFacialRecognitionSupported(documentType) {
         const response = await UqudoId.isFacialRecognitionSupported({ value: documentType });
         return response.value == true;
@@ -508,5 +587,17 @@ export class UqudoPlugin {
         const response = await UqudoId.isReadingSupported({ value: documentType });
         return response.value == true;
     }
+    async isLookupSupported(documentType) {
+        const response = await UqudoId.isLookupSupported({ value: documentType });
+        return response.value == true;
+    }
+    async isLookupFacialRecognitionSupported(documentType) {
+        const response = await UqudoId.isLookupFacialRecognitionSupported({ value: documentType });
+        return response.value == true;
+    }
+    async isEnrollmentSupported(documentType) {
+        const response = await UqudoId.isEnrollmentSupported({ value: documentType });
+        return response.value == true;
+    }
 }
 //# sourceMappingURL=index.js.map