biometry-sdk 1.3.1 → 1.3.3

package/README.md

@@ -41,8 +41,25 @@ const sdk = new BiometrySDK('YOUR_API_KEY');
 ### Example
 You can find an example in the example/ directory. The example demonstrates how you might integrate the BiometrySDK in a React component with the state.
 
-### 1. Consents
-#### 1.1 Give Authorization Consent
+### 1. Sessions
+Session is a way to group transactions together. It is useful when you want to group transactions that are related to each other. For example, you can start a session and then use the session ID to link transactions within a unified group.
+  ```javascript
+  const response = await sdk.startSession();
+  const sessionId = response.data;
+
+  const voiceFile = new File([/* voice audio bytes */], 'voice.wav', { type: 'audio/wav' });
+  const faceFile = new File([/* face image bytes */], 'face.jpg', { type: 'image/jpeg' });
+
+  // Use the session ID to link transactions within a unified group
+  await sdk.giveStorageConsent(true, 'John Doe', { sessionId });
+  await sdk.enrollFace(faceFile, 'John Doe', { sessionId });
+  await sdk.enrollVoice(voiceFile, 'John Doe', { sessionId });
+
+  // Go to the Results page in your dashboard and see the transactions grouped by the session ID
+  ```
+
+### 2. Consents
+#### 2.1 Give Authorization Consent
 You **must** obtain user authorization consent before performing any biometric operations (Face Recognition, Voice Recognition, etc.):
   ```javascript
   await sdk.giveAuthorizationConsent(true, 'John Doe');
@@ -54,7 +71,7 @@ You **must** obtain user authorization consent before performing any biometric o
 - The first argument (`true`) indicates that the user has granted consent.
 - The second argument is the user’s full name (used for record-keeping within Biometry).
 
-#### 1.2 Give Storage Consent
+#### 2.2 Give Storage Consent
 You **must** obtain user consent before storing biometric data (Face Enrollment, Voice Enrollment):
   ```javascript
   await sdk.giveStorageConsent(true, 'John Doe');
@@ -66,7 +83,7 @@ You **must** obtain user consent before storing biometric data (Face Enrollment,
 - The first argument (`true`) indicates that the user has granted consent.
 - The second argument is the user’s full name (used for record-keeping within Biometry).
 
-### 2. Face Enrollment
+### 3. Face Enrollment
 Enroll a user’s face for future recognition or matching:
   ```javascript
   const faceFile = new File([/* face image bytes */], 'face.jpg', { type: 'image/jpeg' });
@@ -76,7 +93,7 @@ Enroll a user’s face for future recognition or matching:
   console.log('Face Enrollment Response:', faceResponse);
   ```
 
-### 3. Voice Enrollment
+### 4. Voice Enrollment
 Enroll a user’s voice for future authentication checks:
   ```javascript
   const voiceFile = new File([/* voice audio bytes */], 'voice.wav', { type: 'audio/wav' });
@@ -85,7 +102,7 @@ Enroll a user’s voice for future authentication checks:
   const voiceResponse = await sdk.enrollVoice(voiceFile, 'John Doe');
   console.log('Voice Enrollment Response:', voiceResponse);
   ```
-### 4. Process Video
+### 5. Process Video
 Process a user’s video for liveness checks and identity authorization:
   ```javascript
   const videoFile = new File([/* file parts */], 'video.mp4', { type: 'video/mp4' });
@@ -97,28 +114,14 @@ Process a user’s video for liveness checks and identity authorization:
   try {
     const response = await sdk.processVideo(videoFile, phrase, userFullName);
     console.log('Process Video Response:', response);
-  
-    // Retrieve the processVideoRequestId from the *response headers* called x-request-id.
   } catch (error) {
     console.error('Error processing video:', error);
   }
   ```
-#### Additional
-- `processVideoRequestId`: After calling `sdk.processVideo()`, you typically receive a unique ID (`x-request-id`). You can pass this `processVideoRequestId` into subsequent calls (e.g., `faceMatch`) to reference the previously uploaded video frames.
-- `usePrefilledVideo`: When set to `true`, indicates that the SDK should reuse the video already on file from a previous `processVideo` call rather than requiring a new upload.
-### 5. Face match
+
+### 6. Face match
 Use matchFaces to compare a reference image (e.g., a document or a captured selfie) with a face from a video:
   ```javascript
-    /**
-   * matchFaces(
-   *   image: File,
-   *   video?: File,
-   *   userFullName?: string,
-   *   processVideoRequestId?: string,
-   *   usePrefilledVideo?: boolean,
-   *   requestUserProvidedId?: string
-   * ): Promise<FaceMatchResponse>
-   */
   const faceFile = new File([/* face image bytes */], 'face.jpg', { type: 'image/jpeg' });
   const videoFile = new File([/* file parts */], 'video.mp4', { type: 'video/mp4' });
   const userFullName = 'John Doe';
@@ -128,34 +131,40 @@ Use matchFaces to compare a reference image (e.g., a document or a captured self
     videoFile,
     userFullName
   );
-  // OR
+  ```
+
+You can also reuse a video that was previously processed with the `processVideo` method by passing the same sessionId:
+  ```javascript
+  const sessionId = await sdk.startSession();
+
+  // First, process a video with a sessionId
+  const processVideoResponse = await sdk.processVideo(videoFile, phrase, userFullName, { sessionId });
+  
+  // Later, reuse the same video for face matching by providing the sessionId
   const faceMatchResponse = await sdk.faceMatch(
-    faceFile,              // The image containing the user's face (doc or selfie)
-    null,                  // No local video provided (we're reusing the old one)
-    'John Doe',
-    processVideoRequestId, // From the /process-video response headers
-    true                   // usePrefilledVideo
+    faceFile,
+    null, // No need to pass the video file again
+    userFullName,
+    true, // usePrefilledVideo
+    { sessionId }
   );
   ```
 
-### 6. Sessions
-Session is a way to group transactions together. It is useful when you want to group transactions that are related to each other. For example, you can start a session and then use the session ID to link transactions within a unified group.
+### 7. DocAuth
+DocAuth is a way to authenticate a user's document. It is useful when you want to authenticate a user's document.
   ```javascript
   const sessionId = await sdk.startSession();
 
-  const videoFile = new File([/* file parts */], 'video.mp4', { type: 'video/mp4' });
-  const phrase = "one two three four five six";
+  const documentFile = new File([/* file parts */], 'document.jpg', { type: 'image/jpeg' });
   const userFullName = 'John Doe';
     
   await sdk.giveAuthorizationConsent(true, userFullName, { sessionId });
     
   try {
-    const response = await sdk.processVideo(videoFile, phrase, userFullName, { sessionId });
-    console.log('Process Video Response:', response);
-    
-    // Retrieve the processVideoRequestId from the *response headers* called x-request-id.
+    const response = await sdk.checkDocAuth(documentFile, userFullName, { sessionId });
+    console.log('DocAuth Response:', response);
   } catch (error) {
-    console.error('Error processing video:', error);
+    console.error('Error checking document:', error);
   }
   ```
 
@@ -168,8 +177,8 @@ One common advanced scenario involves document authentication in enrollment face
 
 Below is a possible flow (method names in your SDK may vary slightly depending on your integration setup):
   ```javascript
-  // 1. Acquire user consent
-  await sdk.giveConsent(true, userFullName);
+  // 1. Acquire user storage consent
+  await sdk.giveStorageConsent(true, userFullName);
   
   // 2. Enroll or capture the user’s face
   //    (Either using enrollFace or processVideo, depending on your user flow)
@@ -177,14 +186,17 @@ Below is a possible flow (method names in your SDK may vary slightly depending o
   const userVideoFile = new File([/* user selfie bytes */], 'video.mp4', { type: 'video/*' });
   const enrollResponse = await sdk.enrollFace(userFaceFile, userFullName);
   
-  // 3. Face Match (Compare video face with user’s enrolled face)
+  // 3. Acquire user authorization consent. It's required to use enrolled face for using biometric data.
+  await sdk.giveAuthorizationConsent(true, userFullName);
+
+  // 4. Face Match (Compare video face with user’s enrolled face)
   const faceMatchResponse = await sdk.faceMatch(
     userFaceFile,
     userVideoFile,
     userFullName
   );
   
-  // 4. Evaluate the faceMatch result
+  // 5. Evaluate the faceMatch result
   if (faceMatchResponse.matchResult === 'match') {
     console.log('User video face matches user’s live face. Identity verified!');
   } else {
@@ -326,50 +338,6 @@ This project is licensed under the MIT License. See the [LICENSE](LICENSE) file
 ## More Information
 For more detailed information on Biometry’s API endpoints, parameters, and responses, visit the official [Biometry API Documentation](https://developer.biometrysolutions.com/overview/). If you have questions or need help, please reach out to our support team or create a GitHub issue.
 
-## Quick Reference
-- **Install**:
-  ```bash
-  npm install biometry-sdk
-  ```
-- **Consent**: (Required before enrollment/processing)
-  ```javascript
-  sdk.giveConsent(true, userFullName)
-  ```
-- **Voice Enrollment**:
-  ```javascript
-  sdk.enrollVoice(file, userFullName)
-  ```
-- **Face Enrollment**:
-  ```javascript
-  sdk.enrollFace(file, userFullName)
-  ```
-- **Face match (basic):**
-  ```javascript
-  sdk.faceMatch(image, video, userFullName);
-  ```
-- **Face match (advanced w/ reusing video or linking IDs):**
-  ```javascript
-  sdk.faceMatch(
-    image,                   // Reference image file that contains user's face.
-    video,                   // Video file that contains user's face.
-    userFullName,
-    processVideoRequestId,   // ID from the response header of /process-video endpoint.
-    usePrefilledVideo        // Pass true to use the video from the process-video endpoint.
-  );
-  ```
-- **Process Video (basic):**
-  ```javascript
-  sdk.processVideo(file, phrase, userFullName);
-  ```
-- **Process Video (advanced w/ reusing video or linking IDs):**
-  ```javascript
-  sdk.processVideo(
-    video, // Video file that you want to process
-    phrase,
-    userFullName,
-    requestUserProvidedId // An optional user-provided ID to link transactions within a unified group
-  );
-  ```
 - **UI Components:**
   - `<biometry-enrollment ...>` (face enrollment)
   - `<process-video ...>` (video enrollment)

package/dist/biometry-sdk.esm.js

@@ -221,11 +221,13 @@ class BiometrySDK {
      * @returns {Promise<FaceMatchResponse>} - A promise resolving to the voice enrolling response.
      * @throws {Error} - If required parameters are missing or the request fails.
      */
-    async matchFaces(image, video, userFullName, processVideoRequestId, usePrefilledVideo, props) {
+    async matchFaces(image, video, userFullName, usePrefilledVideo, props) {
         if (!image)
             throw new Error('Face image is required.');
-        if ((!processVideoRequestId && !usePrefilledVideo) && !video)
+        if ((!usePrefilledVideo) && !video)
             throw new Error('Video is required.');
+        if (usePrefilledVideo && !(props === null || props === undefined ? undefined : props.sessionId))
+            throw new Error('Session ID is required to use a video from the process-video endpoint.');
         const formData = new FormData();
         if (video) {
             formData.append('video', video);
@@ -235,10 +237,7 @@ class BiometrySDK {
         if (userFullName) {
             headers['X-User-Fullname'] = userFullName;
         }
-        if (processVideoRequestId) {
-            headers['X-Request-Id'] = processVideoRequestId;
-        }
-        if (processVideoRequestId && usePrefilledVideo) {
+        if (usePrefilledVideo) {
             headers['X-Use-Prefilled-Video'] = 'true';
         }
         if (props === null || props === undefined ? undefined : props.sessionId) {
@@ -247,9 +246,6 @@ class BiometrySDK {
         if (props === null || props === undefined ? undefined : props.deviceInfo) {
             headers['X-Device-Info'] = JSON.stringify(props.deviceInfo);
         }
-        if (props === null || props === undefined ? undefined : props.deviceInfo) {
-            headers['X-Device-Info'] = JSON.stringify(props.deviceInfo);
-        }
         return await this.request('/api-gateway/match-faces', 'POST', formData, headers);
     }
     /**

package/dist/sdk.d.ts

@@ -116,7 +116,7 @@ export declare class BiometrySDK {
      * @returns {Promise<FaceMatchResponse>} - A promise resolving to the voice enrolling response.
      * @throws {Error} - If required parameters are missing or the request fails.
      */
-    matchFaces(image: File, video?: File, userFullName?: string, processVideoRequestId?: string, usePrefilledVideo?: boolean, props?: {
+    matchFaces(image: File, video?: File, userFullName?: string, usePrefilledVideo?: boolean, props?: {
         sessionId?: string;
         deviceInfo?: object;
     }): Promise<ApiResponse<FaceMatchResponse>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "biometry-sdk",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "main": "dist/biometry-sdk.esm.js",
   "types": "dist/index.d.ts",
   "module": "dist/biometry-sdk.esm.js",

package/dist/components/biometry-onboarding.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/components/biometry-onboarding.js

@@ -1,233 +0,0 @@
-import { BiometrySDK } from "../sdk.js";
-import { BiometryAttributes, BiometryOnboardingState } from "../types.js";
-class BiometryOnboarding extends HTMLElement {
-    constructor() {
-        super();
-        this.videoElement = null;
-        this.canvasElement = null;
-        this.captureButton = null;
-        this.shadow = this.attachShadow({ mode: "open" });
-        this.sdk = null;
-        this.toggleState = this.toggleState.bind(this);
-        this.capturePhoto = this.capturePhoto.bind(this);
-    }
-    static get observedAttributes() {
-        return Object.values(BiometryAttributes);
-    }
-    get apiKey() {
-        return this.getAttribute("api-key");
-    }
-    set apiKey(value) {
-        if (value) {
-            this.setAttribute("api-key", value);
-        }
-        else {
-            this.removeAttribute("api-key");
-        }
-    }
-    get userFullname() {
-        return this.getAttribute("user-fullname");
-    }
-    set userFullname(value) {
-        if (value) {
-            this.setAttribute("user-fullname", value);
-        }
-        else {
-            this.removeAttribute("user-fullname");
-        }
-    }
-    attributeChangedCallback(name, oldValue, newValue) {
-        if (name === "api-key" || name === "user-fullname") {
-            this.validateAttributes();
-        }
-    }
-    connectedCallback() {
-        this.validateAttributes();
-        this.init();
-    }
-    disconnectedCallback() {
-        this.cleanup();
-    }
-    validateAttributes() {
-        if (!this.apiKey) {
-            console.error("API key is required.");
-            this.toggleState(BiometryOnboardingState.ErrorOther);
-            return;
-        }
-        if (!this.userFullname) {
-            console.error("User fullname is required.");
-            this.toggleState(BiometryOnboardingState.ErrorOther);
-            return;
-        }
-    }
-    init() {
-        this.shadow.innerHTML = `
-    <style>
-      .wrapper {
-        position: relative;
-      }
-      video {
-        transform: scaleX(-1); /* Flip video for preview */
-        max-width: 100%;
-        border-radius: var(--border-radius, 8px);
-      }
-      canvas {
-        display: none;
-      }
-    </style>
-    <div class="wrapper">
-      <slot name="video">
-        <video id="video" autoplay playsinline></video>
-      </slot>
-      <slot name="canvas">
-        <canvas id="canvas" style="display: none;"></canvas>
-      </slot>
-      <slot name="button">
-        <button id="button">Capture Photo</button>
-      </slot>
-      <div class="status">
-        <slot name="loading" class="loading"></slot>
-        <slot name="success" class="success"></slot>
-        <slot name="error-no-face" class="error-no-face"></slot>
-        <slot name="error-multiple-faces" class="error-multiple-faces"></slot>
-        <slot name="error-not-centered" class="error-not-centered"></slot>
-        <slot name="error-other" class="error-other"></slot>
-      </div>
-    </div>
-  `;
-        this.initializeSDK();
-        this.attachSlotListeners();
-        this.setupCamera();
-        this.toggleState("");
-    }
-    cleanup() {
-        var _a;
-        if ((_a = this.videoElement) === null || _a === void 0 ? void 0 : _a.srcObject) {
-            const tracks = this.videoElement.srcObject.getTracks();
-            tracks.forEach((track) => track.stop());
-        }
-        if (this.videoElement) {
-            this.videoElement.srcObject = null;
-        }
-    }
-    initializeSDK() {
-        if (this.apiKey) {
-            this.sdk = new BiometrySDK(this.apiKey);
-        }
-        else {
-            this.toggleState(BiometryOnboardingState.ErrorOther);
-            console.error("API key is required to initialize the SDK.");
-        }
-    }
-    toggleState(state) {
-        const slots = [
-            BiometryOnboardingState.Loading,
-            BiometryOnboardingState.Success,
-            BiometryOnboardingState.ErrorNoFace,
-            BiometryOnboardingState.ErrorMultipleFaces,
-            BiometryOnboardingState.ErrorNotCentered,
-            BiometryOnboardingState.ErrorOther,
-        ];
-        slots.forEach((slotName) => {
-            const slot = this.shadow.querySelector(`slot[name="${slotName}"]`);
-            if (slot) {
-                slot.style.display = slotName === state ? "block" : "none";
-            }
-        });
-    }
-    attachSlotListeners() {
-        const videoSlot = this.shadow.querySelector('slot[name="video"]');
-        const canvasSlot = this.shadow.querySelector('slot[name="canvas"]');
-        const buttonSlot = this.shadow.querySelector('slot[name="button"]');
-        const assignedVideoElements = videoSlot.assignedElements();
-        this.videoElement = (assignedVideoElements.length > 0 ? assignedVideoElements[0] : null) || this.shadow.querySelector("#video");
-        const assignedCanvasElements = canvasSlot.assignedElements();
-        this.canvasElement = (assignedCanvasElements.length > 0 ? assignedCanvasElements[0] : null) || this.shadow.querySelector("#canvas");
-        const assignedButtonElements = buttonSlot.assignedElements();
-        this.captureButton = (assignedButtonElements.length > 0 ? assignedButtonElements[0] : null) || this.shadow.querySelector("#button");
-        if (!this.videoElement) {
-            console.error("Video element is missing.");
-            return;
-        }
-        if (!this.captureButton) {
-            console.error("Capture button is missing.");
-            return;
-        }
-        else {
-            this.captureButton.addEventListener("click", this.capturePhoto);
-        }
-    }
-    setupCamera() {
-        if (!this.videoElement) {
-            console.error("Video element is missing.");
-            return;
-        }
-        navigator.mediaDevices
-            .getUserMedia({ video: true })
-            .then((stream) => {
-            this.videoElement.srcObject = stream;
-        })
-            .catch((error) => {
-            console.error("Error accessing camera:", error);
-        });
-    }
-    async capturePhoto() {
-        try {
-            if (!this.videoElement || !this.canvasElement || !this.sdk) {
-                console.error("Essential elements or SDK are not initialized.");
-                return;
-            }
-            const context = this.canvasElement.getContext("2d");
-            this.canvasElement.width = this.videoElement.videoWidth;
-            this.canvasElement.height = this.videoElement.videoHeight;
-            context.drawImage(this.videoElement, 0, 0, this.canvasElement.width, this.canvasElement.height);
-            this.toggleState("loading");
-            this.canvasElement.toBlob(async (blob) => {
-                try {
-                    if (!blob) {
-                        console.error("Failed to capture photo.");
-                        this.toggleState(BiometryOnboardingState.ErrorOther);
-                        return;
-                    }
-                    const file = new File([blob], "onboard-face.jpg", { type: "image/jpeg" });
-                    try {
-                        const response = await this.sdk.onboardFace(file, this.userFullname);
-                        const result = response.data.onboard_result;
-                        this.resultCode = result === null || result === void 0 ? void 0 : result.code;
-                        this.description = (result === null || result === void 0 ? void 0 : result.description) || "Unknown error occurred.";
-                        switch (this.resultCode) {
-                            case 0:
-                                this.toggleState(BiometryOnboardingState.Success);
-                                break;
-                            case 1:
-                                this.toggleState(BiometryOnboardingState.ErrorNoFace);
-                                break;
-                            case 2:
-                                this.toggleState(BiometryOnboardingState.ErrorMultipleFaces);
-                                break;
-                            case 3:
-                                this.toggleState(BiometryOnboardingState.ErrorNotCentered);
-                                break;
-                            default:
-                                this.toggleState(BiometryOnboardingState.ErrorOther);
-                        }
-                        console.log("Onboarding result:", result);
-                    }
-                    catch (error) {
-                        console.error("Error onboarding face:", error);
-                        this.toggleState(BiometryOnboardingState.ErrorOther);
-                    }
-                }
-                catch (error) {
-                    console.error("Error in toBlob callback:", error);
-                    this.toggleState(BiometryOnboardingState.ErrorOther);
-                }
-            }, "image/jpeg");
-        }
-        catch (error) {
-            console.error("Error capturing photo:", error);
-            this.toggleState(BiometryOnboardingState.ErrorOther);
-        }
-    }
-}
-customElements.define("biometry-onboarding", BiometryOnboarding);

package/dist/index.js

@@ -1,2 +0,0 @@
-export * from './sdk';
-export * from './types';

package/dist/sdk.js

@@ -1,179 +0,0 @@
-export class BiometrySDK {
-    constructor(apiKey) {
-        if (!apiKey) {
-            throw new Error('API Key is required to initialize the SDK.');
-        }
-        this.apiKey = apiKey;
-    }
-    async request(path, method, body, headers) {
-        const defaultHeaders = {
-            Authorization: `Bearer ${this.apiKey}`,
-        };
-        const requestHeaders = Object.assign(Object.assign({}, defaultHeaders), headers);
-        if (body && !(body instanceof FormData)) {
-            requestHeaders['Content-Type'] = 'application/json';
-            body = JSON.stringify(body);
-        }
-        const response = await fetch(`${BiometrySDK.BASE_URL}${path}`, {
-            method,
-            headers: requestHeaders,
-            body,
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            const errorMessage = (errorData === null || errorData === void 0 ? void 0 : errorData.error) || (errorData === null || errorData === void 0 ? void 0 : errorData.message) || 'Unknown error occurred';
-            throw new Error(`Error ${response.status}: ${errorMessage}`);
-        }
-        return await response.json();
-    }
-    /**
-     * Submits consent for a user.
-     *
-     * @param {boolean} isConsentGiven - Indicates whether the user has given consent.
-     * @param {string} userFullName - The full name of the user giving consent.
-     * @returns {Promise<ConsentResponse>} A promise resolving to the consent response.
-     * @throws {Error} - If the user's full name is not provided or if the request fails.
-     */
-    async giveConsent(isConsentGiven, userFullName) {
-        if (!userFullName) {
-            throw new Error('User Full Name is required to give consent.');
-        }
-        const body = {
-            is_consent_given: isConsentGiven,
-            user_fullname: userFullName,
-        };
-        const response = await this.request('/api-consent/consent', 'POST', body);
-        return {
-            is_consent_given: response.is_consent_given,
-            user_fullname: response.user_fullname,
-        };
-    }
-    /**
-     * Onboards a user's voice for biometric authentication.
-     *
-     * @param {File} audio - The audio file containing the user's voice.
-     * @param {string} userFullName - The full name of the user being onboarded.
-     * @param {string} uniqueId - A unique identifier for the onboarding process.
-     * @param {string} phrase - The phrase spoken in the audio file.
-     * @param {string} [requestUserProvidedId] - An optional user-provided ID to link transactions within a unified group.
-     * @returns {Promise<VoiceOnboardingResponse>} - A promise resolving to the voice onboarding response.
-     * @throws {Error} - If required parameters are missing or the request fails.
-     */
-    async onboardVoice(audio, userFullName, uniqueId, phrase, requestUserProvidedId) {
-        if (!userFullName)
-            throw new Error('User fullname is required.');
-        if (!uniqueId)
-            throw new Error('Unique ID is required.');
-        if (!phrase)
-            throw new Error('Phrase is required.');
-        if (!audio)
-            throw new Error('Audio file is required.');
-        const formData = new FormData();
-        formData.append('unique_id', uniqueId);
-        formData.append('phrase', phrase);
-        formData.append('voice', audio);
-        const headers = {
-            'X-User-Fullname': userFullName,
-        };
-        if (requestUserProvidedId) {
-            headers['X-Request-User-Provided-ID'] = requestUserProvidedId;
-        }
-        return this.request('/api-gateway/onboard/voice', 'POST', formData, headers);
-    }
-    /**
-     * Onboards a user's face for biometric authentication.
-     *
-     * @param {File} face - Image file that contains user's face.
-     * @param {string} userFullName - The full name of the user being onboarded.
-     * @param {string} isDocument - Indicates whether the image is a document.
-     * @param {string} [requestUserProvidedId] - An optional user-provided ID to link transactions within a unified group.
-     * @returns {Promise<FaceOnboardingResponse>} - A promise resolving to the voice onboarding response.
-     * @throws {Error} - If required parameters are missing or the request fails.
-     */
-    async onboardFace(face, userFullName, isDocument, requestUserProvidedId) {
-        if (!userFullName)
-            throw new Error('User fullname is required.');
-        if (!face)
-            throw new Error('Face image is required.');
-        const formData = new FormData();
-        formData.append('face', face);
-        if (isDocument) {
-            formData.append('is_document', 'true');
-        }
-        const headers = {
-            'X-User-Fullname': userFullName,
-        };
-        if (requestUserProvidedId) {
-            headers['X-Request-User-Provided-ID'] = requestUserProvidedId;
-        }
-        return this.request('/api-gateway/onboard/face', 'POST', formData, headers);
-    }
-    /**
-     * Matches a user's face from video against a reference image.
-     *
-     * @param {File} image - Reference image file that contains user's face.
-     * @param {string} video - Video file that contains user's face.
-     * @param {string} userFullName - Pass the full name of end-user to process Voice and Face recognition services.
-     * @param {string} processVideoRequestId - ID from the response header of /process-video endpoint.
-     * @param {boolean} usePrefilledVideo - Pass true to use the video from the process-video endpoint.
-     * @param {string} [requestUserProvidedId] - An optional user-provided ID to link transactions within a unified group.
-     * @returns {Promise<FaceMatchResponse>} - A promise resolving to the voice onboarding response.
-     * @throws {Error} - If required parameters are missing or the request fails.
-     */
-    async matchFaces(image, video, userFullName, processVideoRequestId, usePrefilledVideo, requestUserProvidedId) {
-        if (!image)
-            throw new Error('Face image is required.');
-        if ((!processVideoRequestId && !usePrefilledVideo) && !video)
-            throw new Error('Video is required.');
-        const formData = new FormData();
-        if (video) {
-            formData.append('video', video);
-        }
-        formData.append('image', image);
-        const headers = {};
-        if (userFullName) {
-            headers['X-User-Fullname'] = userFullName;
-        }
-        if (processVideoRequestId) {
-            headers['X-Request-Id'] = processVideoRequestId;
-        }
-        if (processVideoRequestId && usePrefilledVideo) {
-            headers['X-Use-Prefilled-Video'] = 'true';
-        }
-        if (requestUserProvidedId) {
-            headers['X-Request-User-Provided-ID'] = requestUserProvidedId;
-        }
-        return this.request('/api-gateway/match-faces', 'POST', formData, headers);
-    }
-    /**
-     * Process the video through Biometry services to check liveness and authorize user
-     *
-     * @param {File} video - Video file that you want to process.
-     * @param {string} phrase - Set of numbers that user needs to say out loud in the video.
-     * @param {string} userFullName - Pass the full name of end-user to process Voice and Face recognition services.
-     * @param {string} requestUserProvidedId - An optional user-provided ID to link transactions within a unified group.
-     * @param {object} deviceInfo - Pass the device information in JSON format to include in transaction.
-     * @returns
-     */
-    async processVideo(video, phrase, userFullName, requestUserProvidedId, deviceInfo) {
-        if (!video)
-            throw new Error('Video is required.');
-        if (!phrase)
-            throw new Error('Phrase is required.');
-        const formData = new FormData();
-        formData.append('phrase', phrase);
-        formData.append('video', video);
-        const headers = {};
-        if (userFullName) {
-            headers['X-User-Fullname'] = userFullName;
-        }
-        if (requestUserProvidedId) {
-            headers['X-Request-User-Provided-ID'] = requestUserProvidedId;
-        }
-        if (deviceInfo) {
-            headers['X-Device-Info'] = JSON.stringify(deviceInfo);
-        }
-        return this.request('/api-gateway/process-video', 'POST', formData, headers);
-    }
-}
-BiometrySDK.BASE_URL = 'https://api.biometrysolutions.com';

package/dist/sdk.test.js

@@ -1,255 +0,0 @@
-import { BiometrySDK } from './sdk';
-// Mock the fetch API globally
-global.fetch = jest.fn();
-describe('BiometrySDK', () => {
-    const apiKey = 'test-api-key';
-    const sdk = new BiometrySDK(apiKey);
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    it('should throw an error if no API key is provided', () => {
-        expect(() => new BiometrySDK('')).toThrow('API Key is required to initialize the SDK.');
-    });
-    // CONSENT
-    it('should call fetch with correct headers and body when giving consent', async () => {
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => ({ is_consent_given: true, user_fullname: 'John Doe' }),
-        });
-        const result = await sdk.giveConsent(true, 'John Doe');
-        expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/consent', expect.objectContaining({
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                is_consent_given: true,
-                user_fullname: 'John Doe',
-            }),
-        }));
-        expect(result).toEqual({ is_consent_given: true, user_fullname: 'John Doe', });
-    });
-    it('should throw an error if response is not ok', async () => {
-        fetch.mockResolvedValueOnce({
-            ok: false,
-            status: 400,
-            json: async () => ({ error: 'is_consent_given must be true' }),
-        });
-        await expect(sdk.giveConsent(true, 'John Doe')).rejects.toThrow('Error 400: undefined');
-    });
-    // VOICE ONBOARDING
-    it('should throw an error if user fullname is missing', async () => {
-        const audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-        await expect(sdk.onboardVoice(audioFile, '', 'uniqueId', 'phrase')).rejects.toThrowError('User fullname is required.');
-    });
-    it('should throw an error if unique ID is missing', async () => {
-        const audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-        await expect(sdk.onboardVoice(audioFile, 'User Name', '', 'phrase')).rejects.toThrowError('Unique ID is required.');
-    });
-    it('should throw an error if phrase is missing', async () => {
-        const audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-        await expect(sdk.onboardVoice(audioFile, 'User Name', 'uniqueId', '')).rejects.toThrowError('Phrase is required.');
-    });
-    it('should throw an error if audio file is missing', async () => {
-        await expect(sdk.onboardVoice(null, 'User Name', 'uniqueId', 'phrase')).rejects.toThrowError('Audio file is required.');
-    });
-    it('should successfully onboard voice and return the response', async () => {
-        const mockResponse = {
-            status: 'good',
-        };
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => mockResponse,
-        });
-        const audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-        const userFullName = 'User Name';
-        const uniqueId = 'uniqueId';
-        const phrase = 'phrase';
-        const formDataSpy = jest.spyOn(FormData.prototype, 'append');
-        const result = await sdk.onboardVoice(audioFile, userFullName, uniqueId, phrase);
-        expect(formDataSpy).toHaveBeenCalledWith('unique_id', uniqueId);
-        expect(formDataSpy).toHaveBeenCalledWith('phrase', phrase);
-        expect(formDataSpy).toHaveBeenCalledWith('voice', audioFile);
-        expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/onboard/voice', expect.objectContaining({
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'X-User-Fullname': userFullName,
-            },
-            body: expect.any(FormData)
-        }));
-        expect(result).toEqual(mockResponse);
-    });
-    // FACE ONBOARDING
-    it('should throw an error if user fullname is missing', async () => {
-        const imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-        await expect(sdk.onboardFace(imageFile, '')).rejects.toThrowError('User fullname is required.');
-    });
-    it('should throw an error if image file is missing', async () => {
-        await expect(sdk.onboardFace(null, 'User Name')).rejects.toThrowError('Face image is required.');
-    });
-    it('should successfully onboard face and return the response', async () => {
-        const mockResponse = {
-            code: 200,
-            description: 'Face onboarded successfully',
-        };
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => mockResponse,
-        });
-        const imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-        const userFullName = 'User Name';
-        const formDataSpy = jest.spyOn(FormData.prototype, 'append');
-        const result = await sdk.onboardFace(imageFile, userFullName);
-        expect(formDataSpy).toHaveBeenCalledWith('face', imageFile);
-        expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/onboard/face', expect.objectContaining({
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'X-User-Fullname': userFullName,
-            },
-            body: expect.any(FormData)
-        }));
-        expect(result).toEqual(mockResponse);
-    });
-    // FACE MATCH
-    it('should throw an error if face image is missing', async () => {
-        await expect(sdk.matchFaces(null, null)).rejects.toThrowError('Face image is required.');
-    });
-    it('should throw an error if video file is missing', async () => {
-        const imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-        await expect(sdk.matchFaces(imageFile, null)).rejects.toThrowError('Video is required.');
-    });
-    it('should successfully match faces and return the response', async () => {
-        const mockResponse = {
-            code: 200,
-            result: 1,
-            description: 'Matched',
-            anchor: {
-                code: 200,
-                description: 'Anchor face',
-            },
-            target: {
-                code: 200,
-                description: 'Target face',
-            },
-        };
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => mockResponse,
-        });
-        const imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-        const videoFile = new File(['video data'], 'video.mp4', { type: 'video/mp4' });
-        const formDataSpy = jest.spyOn(FormData.prototype, 'append');
-        const result = await sdk.matchFaces(imageFile, videoFile);
-        expect(formDataSpy).toHaveBeenCalledWith('video', videoFile);
-        expect(formDataSpy).toHaveBeenCalledWith('image', imageFile);
-        expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/match-faces', expect.objectContaining({
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-            },
-            body: expect.any(FormData)
-        }));
-        expect(result).toEqual(mockResponse);
-    });
-    it('should successfully match faces if processVideoRequestId is provided', async () => {
-        const mockResponse = {
-            code: 200,
-            result: 1,
-            description: 'Matched',
-            anchor: {
-                code: 200,
-                description: 'Anchor face',
-            },
-            target: {
-                code: 200,
-                description: 'Target face',
-            },
-        };
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => mockResponse,
-        });
-        const imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-        const formDataSpy = jest.spyOn(FormData.prototype, 'append');
-        const result = await sdk.matchFaces(imageFile, undefined, 'User Name', 'processVideoRequestId', true);
-        expect(formDataSpy).toHaveBeenCalledWith('image', imageFile);
-        expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/match-faces', expect.objectContaining({
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-                'X-User-Fullname': 'User Name',
-                'X-Request-Id': 'processVideoRequestId',
-                'X-Use-Prefilled-Video': 'true',
-            },
-            body: expect.any(FormData)
-        }));
-        expect(result).toEqual(mockResponse);
-    });
-    // PROCESS VIDEO
-    it('should throw an error if video file is missing', async () => {
-        await expect(sdk.processVideo(null, 'phrase')).rejects.toThrowError('Video is required.');
-    });
-    it('should throw an error if phrase is missing', async () => {
-        const videoFile = new File(['video data'], 'video.mp4', { type: 'video/mp4' });
-        await expect(sdk.processVideo(videoFile, '')).rejects.toThrowError('Phrase is required.');
-    });
-    it('should successfully process video and return the response', async () => {
-        const mockResponse = {
-            data: {
-                'Active Speaker Detection': {
-                    code: 0,
-                    description: 'Successful check',
-                    result: 90.00,
-                },
-                'Face Liveness Detection': {
-                    code: 0,
-                    description: 'Successful check',
-                    result: true,
-                },
-                'Face Recognition': {
-                    code: 0,
-                    description: 'Successful check',
-                },
-                'Visual Speech Recognition': {
-                    code: 0,
-                    description: 'Successful check',
-                    result: 'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT',
-                },
-                'Voice Recognition': {
-                    status: 'good',
-                    id: '123',
-                    score: 0.99,
-                    imposter_prob: 0.01,
-                    log_odds: '1.0',
-                },
-            },
-            result_conditions: {
-                failed_conditions: [],
-                failed_refer_conditions: [],
-                status: 'pass',
-            },
-            message: 'video processed successfully',
-        };
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            json: async () => mockResponse,
-        });
-        const videoFile = new File(['video data'], 'video.mp4', { type: 'video/mp4' });
-        const phrase = 'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT';
-        const formDataSpy = jest.spyOn(FormData.prototype, 'append');
-        const result = await sdk.processVideo(videoFile, phrase);
-        expect(formDataSpy).toHaveBeenCalledWith('video', videoFile);
-        expect(formDataSpy).toHaveBeenCalledWith('phrase', phrase);
-        expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/process-video', expect.objectContaining({
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${apiKey}`,
-            },
-            body: expect.any(FormData)
-        }));
-        expect(result).toEqual(mockResponse);
-    });
-});

package/dist/types.d.ts

@@ -1,105 +0,0 @@
-export declare enum BiometryAttributes {
-    ApiKey = "api-key",
-    UserFullname = "user-fullname"
-}
-export declare enum BiometryOnboardingState {
-    Loading = "loading",
-    Success = "success",
-    ErrorNoFace = "error-no-face",
-    ErrorMultipleFaces = "error-multiple-faces",
-    ErrorNotCentered = "error-not-centered",
-    ErrorOther = "error-other"
-}
-export interface ConsentResponse {
-    is_consent_given: boolean;
-    user_fullname: string;
-}
-export interface VoiceOnboardingResponse {
-    status: "good" | "qafailed" | "enrolled";
-}
-type Base64String = string & {
-    readonly __brand: unique symbol;
-};
-export interface DocAuthInfo {
-    document_type: string;
-    country_code: string;
-    nationality_code: string;
-    nationality_name: string;
-    sex: string;
-    first_name: string;
-    father_name: string;
-    last_name: string;
-    expiry_date: string;
-    document_number: string;
-    birth_date: string;
-    portrait_photo: Base64String;
-    signature: Base64String;
-    document_category: string;
-    issuing_state: string;
-    front_document_type_id: string;
-    contains_rfid: boolean;
-    errors?: string[];
-}
-export interface FaceOnboardingResponse {
-    data: {
-        onboard_result: FaceOnboardingResult;
-        document_auth?: DocAuthInfo;
-    };
-    message?: string;
-    error?: string;
-    scoring_result?: string;
-}
-export interface FaceOnboardingResult {
-    code: number;
-    description: string;
-}
-export interface FaceMatchResponse {
-    code: number;
-    result: number;
-    description: string;
-    anchor: {
-        code: number;
-        description: string;
-    };
-    target: {
-        code: number;
-        description: string;
-    };
-}
-export interface ProcessVideoResponse {
-    data: {
-        "Active Speaker Detection": {
-            code: number;
-            description: string;
-            result: number;
-        };
-        "Face Liveness Detection": {
-            code: number;
-            description: string;
-            result: boolean;
-        };
-        "Face Recognition": {
-            code: number;
-            description: string;
-        };
-        "Visual Speech Recognition": {
-            code: number;
-            description: string;
-            result: string;
-        };
-        "Voice Recognition": {
-            status: string;
-            id: string;
-            score: number;
-            imposter_prob: number;
-            log_odds: string;
-        };
-    };
-    result_conditions: {
-        failed_conditions: any[];
-        failed_refer_conditions: any[];
-        status: string;
-    };
-    message: string;
-}
-export {};

package/dist/types.js

@@ -1,14 +0,0 @@
-export var BiometryAttributes;
-(function (BiometryAttributes) {
-    BiometryAttributes["ApiKey"] = "api-key";
-    BiometryAttributes["UserFullname"] = "user-fullname";
-})(BiometryAttributes || (BiometryAttributes = {}));
-export var BiometryOnboardingState;
-(function (BiometryOnboardingState) {
-    BiometryOnboardingState["Loading"] = "loading";
-    BiometryOnboardingState["Success"] = "success";
-    BiometryOnboardingState["ErrorNoFace"] = "error-no-face";
-    BiometryOnboardingState["ErrorMultipleFaces"] = "error-multiple-faces";
-    BiometryOnboardingState["ErrorNotCentered"] = "error-not-centered";
-    BiometryOnboardingState["ErrorOther"] = "error-other";
-})(BiometryOnboardingState || (BiometryOnboardingState = {}));