biometry-sdk 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { BiometrySDK } from './sdk';
-export type { ConsentResponse, VoiceOnboardingResponse, FaceOnboardingResponse, FaceMatchResponse, ProcessVideoResponse } from './types';
+export * from './sdk';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,18 @@
+"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);

package/dist/sdk.js

@@ -0,0 +1,272 @@
+"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) {
+        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()];
+                }
+            });
+        });
+    };
+    /**
+     * 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.
+     */
+    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,
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * 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.
+     */
+    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)];
+            });
+        });
+    };
+    /**
+     * 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.
+     */
+    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)];
+            });
+        });
+    };
+    /**
+     * 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.
+     */
+    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)];
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    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;

package/dist/sdk.test.d.ts

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

package/dist/sdk.test.js

@@ -0,0 +1,451 @@
+"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");
+// 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 () {
+        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.');
+    });
+    // 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*/];
+            }
+        });
+    }); });
+    // 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*/];
+            }
+        });
+    }); });
+    // 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*/];
+            }
+        });
+    }); });
+    // 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*/];
+            }
+        });
+    }); });
+    // 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*/];
+            }
+        });
+    }); });
+});

package/dist/types.js

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

package/package.json

@@ -1,42 +1,16 @@
 {
   "name": "biometry-sdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "dist/index.js",
-  "module": "dist/index.m.js",
-  "unpkg": "dist/index.umd.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
   "scripts": {
-    "build": "tsc",
-    "test": "jest"
+    "build": "tsc"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": "",
   "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.7.2"
-  },
-  "compilerOptions": {
-    "target": "ES2017",
-    "module": "CommonJS",
-    "outDir": "./dist",
-    "strict": true,
-    "declaration": true
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ]
+    "typescript": "^5.0.0"
+  }
 }