biometry-sdk 1.0.3 → 1.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [BIOMETRY]
+
+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

@@ -28,3 +28,15 @@ const userFullName = "John Doe";
 const response = await sdk.processVideo(videoFile, phrase, userFullName);
 console.log(response);
 ```
+
+## Example
+
+You can find an example in the example/ directory. The example demonstrates how to integrate the SDK into a React app.
+
+### License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
+
+### More Information
+
+For more detailed documentation on the Biometry API, visit the [official documentation](https://developer.biometrysolutions.com/overview/).

package/dist/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./sdk"), exports);
-__exportStar(require("./types"), exports);
+export * from './sdk';
+export * from './types';

package/dist/sdk.js

@@ -1,92 +1,30 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BiometrySDK = void 0;
-var BiometrySDK = /** @class */ (function () {
-    function BiometrySDK(apiKey) {
+export class BiometrySDK {
+    constructor(apiKey) {
         if (!apiKey) {
             throw new Error('API Key is required to initialize the SDK.');
         }
         this.apiKey = apiKey;
     }
-    BiometrySDK.prototype.request = function (path, method, body, headers) {
-        return __awaiter(this, void 0, void 0, function () {
-            var defaultHeaders, requestHeaders, response, error;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        defaultHeaders = {
-                            Authorization: "Bearer ".concat(this.apiKey),
-                        };
-                        requestHeaders = __assign(__assign({}, defaultHeaders), headers);
-                        if (body && !(body instanceof FormData)) {
-                            requestHeaders['Content-Type'] = 'application/json';
-                            body = JSON.stringify(body);
-                        }
-                        return [4 /*yield*/, fetch("".concat(BiometrySDK.BASE_URL).concat(path), {
-                                method: method,
-                                headers: requestHeaders,
-                                body: body,
-                            })];
-                    case 1:
-                        response = _a.sent();
-                        if (!!response.ok) return [3 /*break*/, 3];
-                        return [4 /*yield*/, response.json()];
-                    case 2:
-                        error = _a.sent();
-                        throw new Error("Error ".concat(response.status, ": ").concat(error.message));
-                    case 3: return [4 /*yield*/, response.json()];
-                    case 4: return [2 /*return*/, _a.sent()];
-                }
-            });
+    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 error = await response.json();
+            throw new Error(`Error ${response.status}: ${error.message}`);
+        }
+        return await response.json();
+    }
     /**
      * Submits consent for a user.
      *
@@ -95,30 +33,20 @@ var BiometrySDK = /** @class */ (function () {
      * @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.
      */
-    BiometrySDK.prototype.giveConsent = function (isConsentGiven, userFullName) {
-        return __awaiter(this, void 0, void 0, function () {
-            var body, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!userFullName) {
-                            throw new Error('User Full Name is required to give consent.');
-                        }
-                        body = {
-                            is_consent_given: isConsentGiven,
-                            user_fullname: userFullName,
-                        };
-                        return [4 /*yield*/, this.request('/consent', 'POST', body)];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, {
-                                is_consent_given: response.is_consent_given,
-                                user_fullname: response.user_fullname,
-                            }];
-                }
-            });
-        });
-    };
+    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('/consent', 'POST', body);
+        return {
+            is_consent_given: response.is_consent_given,
+            user_fullname: response.user_fullname,
+        };
+    }
     /**
      * Onboards a user's voice for biometric authentication.
      *
@@ -130,32 +58,27 @@ var BiometrySDK = /** @class */ (function () {
      * @returns {Promise<VoiceOnboardingResponse>} - A promise resolving to the voice onboarding response.
      * @throws {Error} - If required parameters are missing or the request fails.
      */
-    BiometrySDK.prototype.onboardVoice = function (audio, userFullName, uniqueId, phrase, requestUserProvidedId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var formData, headers;
-            return __generator(this, function (_a) {
-                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.');
-                formData = new FormData();
-                formData.append('unique_id', uniqueId);
-                formData.append('phrase', phrase);
-                formData.append('voice', audio);
-                headers = {
-                    'X-User-Fullname': userFullName,
-                };
-                if (requestUserProvidedId) {
-                    headers['X-Request-User-Provided-ID'] = requestUserProvidedId;
-                }
-                return [2 /*return*/, this.request('/api-gateway/onboard/voice', 'POST', formData, headers)];
-            });
-        });
-    };
+    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.
      *
@@ -166,29 +89,24 @@ var BiometrySDK = /** @class */ (function () {
      * @returns {Promise<FaceOnboardingResponse>} - A promise resolving to the voice onboarding response.
      * @throws {Error} - If required parameters are missing or the request fails.
      */
-    BiometrySDK.prototype.onboardFace = function (face, userFullName, isDocument, requestUserProvidedId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var formData, headers;
-            return __generator(this, function (_a) {
-                if (!userFullName)
-                    throw new Error('User fullname is required.');
-                if (!face)
-                    throw new Error('Face image is required.');
-                formData = new FormData();
-                formData.append('face', face);
-                if (isDocument) {
-                    formData.append('is_document', 'true');
-                }
-                headers = {
-                    'X-User-Fullname': userFullName,
-                };
-                if (requestUserProvidedId) {
-                    headers['X-Request-User-Provided-ID'] = requestUserProvidedId;
-                }
-                return [2 /*return*/, this.request('/api-gateway/onboard/face', 'POST', formData, headers)];
-            });
-        });
-    };
+    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.
      *
@@ -201,36 +119,31 @@ var BiometrySDK = /** @class */ (function () {
      * @returns {Promise<FaceMatchResponse>} - A promise resolving to the voice onboarding response.
      * @throws {Error} - If required parameters are missing or the request fails.
      */
-    BiometrySDK.prototype.matchFaces = function (image, video, userFullName, processVideoRequestId, usePrefilledVideo, requestUserProvidedId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var formData, headers;
-            return __generator(this, function (_a) {
-                if (!image)
-                    throw new Error('Face image is required.');
-                if ((!processVideoRequestId && !usePrefilledVideo) && !video)
-                    throw new Error('Video is required.');
-                formData = new FormData();
-                if (video) {
-                    formData.append('video', video);
-                }
-                formData.append('image', image);
-                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 [2 /*return*/, this.request('/api-gateway/match-faces', 'POST', formData, headers)];
-            });
-        });
-    };
+    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
      *
@@ -241,32 +154,25 @@ var BiometrySDK = /** @class */ (function () {
      * @param {object} deviceInfo - Pass the device information in JSON format to include in transaction.
      * @returns
      */
-    BiometrySDK.prototype.processVideo = function (video, phrase, userFullName, requestUserProvidedId, deviceInfo) {
-        return __awaiter(this, void 0, void 0, function () {
-            var formData, headers;
-            return __generator(this, function (_a) {
-                if (!video)
-                    throw new Error('Video is required.');
-                if (!phrase)
-                    throw new Error('Phrase is required.');
-                formData = new FormData();
-                formData.append('phrase', phrase);
-                formData.append('video', video);
-                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 [2 /*return*/, this.request('/api-gateway/process-video', 'POST', formData, headers)];
-            });
-        });
-    };
-    BiometrySDK.BASE_URL = 'https://api.biometrysolutions.com';
-    return BiometrySDK;
-}());
-exports.BiometrySDK = BiometrySDK;
+    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,451 +1,255 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var sdk_1 = require("./sdk");
+import { BiometrySDK } from './sdk';
 // Mock the fetch API globally
 global.fetch = jest.fn();
-describe('BiometrySDK', function () {
-    var apiKey = 'test-api-key';
-    var sdk = new sdk_1.BiometrySDK(apiKey);
-    afterEach(function () {
+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', function () {
-        expect(function () { return new sdk_1.BiometrySDK(''); }).toThrow('API Key is required to initialize the SDK.');
+    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', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    fetch.mockResolvedValueOnce({
-                        ok: true,
-                        json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, ({ is_consent_given: true, user_fullname: 'John Doe' })];
-                        }); }); },
-                    });
-                    return [4 /*yield*/, sdk.giveConsent(true, 'John Doe')];
-                case 1:
-                    result = _a.sent();
-                    expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/consent', expect.objectContaining({
-                        method: 'POST',
-                        headers: {
-                            Authorization: "Bearer ".concat(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', });
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if response is not ok', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    fetch.mockResolvedValueOnce({
-                        ok: false,
-                        status: 400,
-                        json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, ({ error: 'is_consent_given must be true' })];
-                        }); }); },
-                    });
-                    return [4 /*yield*/, expect(sdk.giveConsent(true, 'John Doe')).rejects.toThrow('Error 400: undefined')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
+    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', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var audioFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-                    return [4 /*yield*/, expect(sdk.onboardVoice(audioFile, '', 'uniqueId', 'phrase')).rejects.toThrowError('User fullname is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if unique ID is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var audioFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-                    return [4 /*yield*/, expect(sdk.onboardVoice(audioFile, 'User Name', '', 'phrase')).rejects.toThrowError('Unique ID is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if phrase is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var audioFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-                    return [4 /*yield*/, expect(sdk.onboardVoice(audioFile, 'User Name', 'uniqueId', '')).rejects.toThrowError('Phrase is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if audio file is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, expect(sdk.onboardVoice(null, 'User Name', 'uniqueId', 'phrase')).rejects.toThrowError('Audio file is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should successfully onboard voice and return the response', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResponse, audioFile, userFullName, uniqueId, phrase, formDataSpy, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    mockResponse = {
-                        status: 'good',
-                    };
-                    fetch.mockResolvedValueOnce({
-                        ok: true,
-                        json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, mockResponse];
-                        }); }); },
-                    });
-                    audioFile = new File(['audio data'], 'audio.wav', { type: 'audio/wav' });
-                    userFullName = 'User Name';
-                    uniqueId = 'uniqueId';
-                    phrase = 'phrase';
-                    formDataSpy = jest.spyOn(FormData.prototype, 'append');
-                    return [4 /*yield*/, sdk.onboardVoice(audioFile, userFullName, uniqueId, phrase)];
-                case 1:
-                    result = _a.sent();
-                    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 ".concat(apiKey),
-                            'X-User-Fullname': userFullName,
-                        },
-                        body: expect.any(FormData)
-                    }));
-                    expect(result).toEqual(mockResponse);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    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', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var imageFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-                    return [4 /*yield*/, expect(sdk.onboardFace(imageFile, '')).rejects.toThrowError('User fullname is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if image file is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, expect(sdk.onboardFace(null, 'User Name')).rejects.toThrowError('Face image is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should successfully onboard face and return the response', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResponse, imageFile, userFullName, formDataSpy, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    mockResponse = {
-                        code: 200,
-                        description: 'Face onboarded successfully',
-                    };
-                    fetch.mockResolvedValueOnce({
-                        ok: true,
-                        json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, mockResponse];
-                        }); }); },
-                    });
-                    imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-                    userFullName = 'User Name';
-                    formDataSpy = jest.spyOn(FormData.prototype, 'append');
-                    return [4 /*yield*/, sdk.onboardFace(imageFile, userFullName)];
-                case 1:
-                    result = _a.sent();
-                    expect(formDataSpy).toHaveBeenCalledWith('face', imageFile);
-                    expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/onboard/face', expect.objectContaining({
-                        method: 'POST',
-                        headers: {
-                            'Authorization': "Bearer ".concat(apiKey),
-                            'X-User-Fullname': userFullName,
-                        },
-                        body: expect.any(FormData)
-                    }));
-                    expect(result).toEqual(mockResponse);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    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', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, expect(sdk.matchFaces(null, null)).rejects.toThrowError('Face image is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if video file is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var imageFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-                    return [4 /*yield*/, expect(sdk.matchFaces(imageFile, null)).rejects.toThrowError('Video is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should successfully match faces and return the response', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResponse, imageFile, videoFile, formDataSpy, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    mockResponse = {
-                        code: 200,
-                        result: 1,
-                        description: 'Matched',
-                        anchor: {
-                            code: 200,
-                            description: 'Anchor face',
-                        },
-                        target: {
-                            code: 200,
-                            description: 'Target face',
-                        },
-                    };
-                    fetch.mockResolvedValueOnce({
-                        ok: true,
-                        json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, mockResponse];
-                        }); }); },
-                    });
-                    imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-                    videoFile = new File(['video data'], 'video.mp4', { type: 'video/mp4' });
-                    formDataSpy = jest.spyOn(FormData.prototype, 'append');
-                    return [4 /*yield*/, sdk.matchFaces(imageFile, videoFile)];
-                case 1:
-                    result = _a.sent();
-                    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 ".concat(apiKey),
-                        },
-                        body: expect.any(FormData)
-                    }));
-                    expect(result).toEqual(mockResponse);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should successfully match faces if processVideoRequestId is provided', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResponse, imageFile, formDataSpy, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    mockResponse = {
-                        code: 200,
-                        result: 1,
-                        description: 'Matched',
-                        anchor: {
-                            code: 200,
-                            description: 'Anchor face',
-                        },
-                        target: {
-                            code: 200,
-                            description: 'Target face',
-                        },
-                    };
-                    fetch.mockResolvedValueOnce({
-                        ok: true,
-                        json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, mockResponse];
-                        }); }); },
-                    });
-                    imageFile = new File(['image data'], 'image.jpg', { type: 'image/jpeg' });
-                    formDataSpy = jest.spyOn(FormData.prototype, 'append');
-                    return [4 /*yield*/, sdk.matchFaces(imageFile, undefined, 'User Name', 'processVideoRequestId', true)];
-                case 1:
-                    result = _a.sent();
-                    expect(formDataSpy).toHaveBeenCalledWith('image', imageFile);
-                    expect(fetch).toHaveBeenCalledWith('https://api.biometrysolutions.com/api-gateway/match-faces', expect.objectContaining({
-                        method: 'POST',
-                        headers: {
-                            'Authorization': "Bearer ".concat(apiKey),
-                            'X-User-Fullname': 'User Name',
-                            'X-Request-Id': 'processVideoRequestId',
-                            'X-Use-Prefilled-Video': 'true',
-                        },
-                        body: expect.any(FormData)
-                    }));
-                    expect(result).toEqual(mockResponse);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    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', function () { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, expect(sdk.processVideo(null, 'phrase')).rejects.toThrowError('Video is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should throw an error if phrase is missing', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var videoFile;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    videoFile = new File(['video data'], 'video.mp4', { type: 'video/mp4' });
-                    return [4 /*yield*/, expect(sdk.processVideo(videoFile, '')).rejects.toThrowError('Phrase is required.')];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it('should successfully process video and return the response', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var mockResponse, videoFile, phrase, formDataSpy, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    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: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                            return [2 /*return*/, mockResponse];
-                        }); }); },
-                    });
-                    videoFile = new File(['video data'], 'video.mp4', { type: 'video/mp4' });
-                    phrase = 'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT';
-                    formDataSpy = jest.spyOn(FormData.prototype, 'append');
-                    return [4 /*yield*/, sdk.processVideo(videoFile, phrase)];
-                case 1:
-                    result = _a.sent();
-                    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 ".concat(apiKey),
-                        },
-                        body: expect.any(FormData)
-                    }));
-                    expect(result).toEqual(mockResponse);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
+    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.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "biometry-sdk",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -12,5 +12,6 @@
   },
   "devDependencies": {
     "typescript": "^5.0.0"
-  }
+  },
+  "license": "MIT"
 }