santoid-sdk 2.0.2 → 3.0.0

package/liveness/methods/uploadIdentificationDocument/Service.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadIdentificationDocumentService = void 0;
+const TypificationService_1 = require("../../../api/TypificationService");
+const FaceMatchService_1 = require("../../../api/FaceMatchService");
+const error_1 = require("../../../utils/error");
+const index_1 = require("../../utils/index");
+class UploadIdentificationDocumentService {
+    constructor(options, internalOptions) {
+        this.results = {
+            uploadedDocument: null,
+            typification: { status: null, results: null, loading: false, error: null },
+            liveness: { status: null, results: null, loading: false, error: null },
+            faceMatch: { status: null, results: null, loading: false, error: null },
+        };
+        this.options = options;
+        this.internalOptions = internalOptions;
+        this.typificationService = new TypificationService_1.TypificationService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
+        this.faceMatchService = new FaceMatchService_1.FaceMatchService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
+    }
+    getResults() {
+        return this.results;
+    }
+    async updateResults(updatedResults) {
+        var _a, _b, _c, _d, _e, _f;
+        this.results = Object.assign(Object.assign({}, this.results), updatedResults);
+        await ((_b = (_a = this.options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, this.results));
+        if (Object.entries(this.results).every(([key, value]) => key === 'uploadedDocument' || !!value.results)) {
+            await ((_d = (_c = this.options).onSuccess) === null || _d === void 0 ? void 0 : _d.call(_c, this.results));
+            await ((_f = (_e = this.options).onEnd) === null || _f === void 0 ? void 0 : _f.call(_e));
+            return;
+        }
+        if (!this.results.faceMatch.results && this.results.faceMatch.status !== 'error') {
+            void this.tryStartFaceMatch();
+        }
+    }
+    updateUploadedDocument(file) {
+        this.results.uploadedDocument = file;
+        if (!this.results.faceMatch.results) {
+            void this.tryStartFaceMatch();
+        }
+    }
+    async startDocumentUpload(file) {
+        var _a, _b, _c;
+        try {
+            void this.updateResults({ typification: { status: null, results: null, loading: true, error: null } });
+            this.updateUploadedDocument(file);
+            const typificationResults = await this.typificationService.predict(file);
+            void this.updateResults({ typification: { status: 'success', results: typificationResults, loading: false, error: null } });
+        }
+        catch (err) {
+            await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({
+                message: 'Error during typification',
+                code: error_1.EUploadIdentificationDocumentErrorCodes.TYPIFICATION_ERROR,
+                details: err,
+            })));
+            void this.updateResults({ typification: { status: 'error', results: null, loading: false, error: (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.data } });
+        }
+    }
+    startLivenessDetection(startLivenessDetectionOptions) {
+        var _a, _b, _c;
+        const adaptedLivenessDetection = Object.assign(Object.assign({}, this.options.livenessDetectionOptions), startLivenessDetectionOptions);
+        void this.updateResults({ liveness: { results: null, status: null, loading: true, error: null } });
+        try {
+            return this.internalOptions.livenessDetection(Object.assign(Object.assign({ domain: this.options.domain, customId: this.options.customId, customWebSocketUrl: this.options.customWebSocketUrl, token: this.options.token, track: this.options.track }, adaptedLivenessDetection), { onSuccess: async (livenessResults) => {
+                    var _a;
+                    await ((_a = adaptedLivenessDetection === null || adaptedLivenessDetection === void 0 ? void 0 : adaptedLivenessDetection.onSuccess) === null || _a === void 0 ? void 0 : _a.call(adaptedLivenessDetection, livenessResults));
+                    void this.updateResults({
+                        liveness: {
+                            status: 'success',
+                            results: (livenessResults),
+                            loading: false,
+                            error: null,
+                        },
+                    });
+                }, onError: async (livenessErrorDetails) => {
+                    var _a, _b, _c;
+                    await ((_a = adaptedLivenessDetection === null || adaptedLivenessDetection === void 0 ? void 0 : adaptedLivenessDetection.onError) === null || _a === void 0 ? void 0 : _a.call(adaptedLivenessDetection, livenessErrorDetails));
+                    await ((_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, livenessErrorDetails));
+                    void this.updateResults({
+                        liveness: {
+                            status: 'error',
+                            results: null,
+                            loading: (livenessErrorDetails === null || livenessErrorDetails === void 0 ? void 0 : livenessErrorDetails.code) === 'wrong-position',
+                            error: livenessErrorDetails,
+                        },
+                    });
+                } }));
+        }
+        catch (err) {
+            void ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({
+                message: 'Error during liveness detection',
+                code: error_1.EUploadIdentificationDocumentErrorCodes.LIVENESS_DETECTION_ERROR,
+                details: err,
+            })));
+            void this.updateResults({ liveness: { status: 'error', results: null, loading: false, error: (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.data } });
+        }
+    }
+    async startFaceMatch(firstImage, secondImage) {
+        var _a, _b, _c;
+        try {
+            void this.updateResults({ faceMatch: { status: null, results: null, loading: true, error: null } });
+            const faceMatchResults = await this.faceMatchService.faceMatch(firstImage, secondImage);
+            void this.updateResults({ faceMatch: { results: faceMatchResults, status: 'success', loading: false, error: null } });
+        }
+        catch (err) {
+            await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({
+                message: 'Error when comparing the face with the document',
+                code: error_1.EUploadIdentificationDocumentErrorCodes.FACE_MATCH_ERROR,
+                details: err,
+            })));
+            void this.updateResults({ faceMatch: { results: null, status: 'error', loading: false, error: (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.data } });
+        }
+    }
+    async tryStartFaceMatch() {
+        var _a, _b, _c;
+        if (this.results.uploadedDocument &&
+            ((_a = this.results.liveness.results) === null || _a === void 0 ? void 0 : _a.successFrames.front) &&
+            !this.results.faceMatch.loading) {
+            await this.startFaceMatch(this.results.uploadedDocument, this.results.liveness.results.successFrames.front);
+        }
+        else {
+            await ((_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, new error_1.SDKError({
+                message: 'Unavailable faces',
+                code: error_1.EUploadIdentificationDocumentErrorCodes.FACE_MATCH_UNAVAILABLE_FACES_ERROR,
+            })));
+        }
+    }
+    startAll(file, startLivenessDetectionOptions) {
+        void this.startDocumentUpload(file);
+        void this.startLivenessDetection(startLivenessDetectionOptions);
+    }
+}
+exports.UploadIdentificationDocumentService = UploadIdentificationDocumentService;

package/liveness/methods/uploadIdentificationDocument/index.d.ts

@@ -0,0 +1,24 @@
+import { type IServiceOptions } from './Service';
+import { type TFrameType, type TMediaType } from '../livenessDetection';
+type TFileType = Blob | File;
+export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType, TMediaType, TFileType>): {
+    startDocumentUpload: (file: TFileType) => Promise<void>;
+    startLivenessDetection: (startLivenessDetectionOptions?: (Omit<import("../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
+        track?: string | undefined;
+        token?: string | undefined;
+    }) | undefined) => (Omit<{
+        getVideoStream: () => TMediaType;
+        stopLivenessDetection: () => Promise<void>;
+        resumeGettingFrames: () => void;
+        pauseGettingFrames: () => void;
+    }, "getVideoStream"> & {
+        getVideoStream?: (() => TMediaType) | undefined;
+    }) | undefined;
+    startFaceComparison: () => Promise<void>;
+    startAll: (file: TFileType, startLivenessDetectionOptions?: (Omit<import("../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
+        track?: string | undefined;
+        token?: string | undefined;
+    }) | undefined) => void;
+    getResults: () => import("./Service").IUploadIdentificationDocumentResults<TFileType>;
+};
+export {};

package/liveness/methods/uploadIdentificationDocument/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadIdentificationDocument = void 0;
+const Service_1 = require("./Service");
+const livenessDetection_1 = require("../livenessDetection");
+function uploadIdentificationDocument(options) {
+    const uploadIdentificationDocumentService = new Service_1.UploadIdentificationDocumentService(options, { livenessDetection: livenessDetection_1.livenessDetection });
+    return {
+        startDocumentUpload: async (...rest) => {
+            await uploadIdentificationDocumentService.startDocumentUpload(...rest);
+        },
+        startLivenessDetection: (...rest) => {
+            return uploadIdentificationDocumentService.startLivenessDetection(...rest);
+        },
+        startFaceComparison: async (...rest) => {
+            await uploadIdentificationDocumentService.tryStartFaceMatch(...rest);
+        },
+        startAll: (...rest) => {
+            uploadIdentificationDocumentService.startAll(...rest);
+        },
+        getResults: (...rest) => {
+            return uploadIdentificationDocumentService.getResults(...rest);
+        },
+    };
+}
+exports.uploadIdentificationDocument = uploadIdentificationDocument;

package/liveness/utils/getNextFrame.d.ts

@@ -1,6 +1,7 @@
-export interface builtInGetNextFrameReturn {
-    getNextFrame: () => Promise<Blob | null>;
-    stopGetNextFrame: () => void;
-    videoStream: MediaStream | undefined;
+export interface IFrameControls<TFrameType, TMediaType> {
+    startGettingFrames?: () => TMediaType | Promise<TMediaType>;
+    getNextFrame?: () => TFrameType | Promise<TFrameType>;
+    stopGettingFrames?: () => void | Promise<void>;
+    videoStream?: TMediaType;
 }
-export declare function builtInGetNextFrame(): Promise<builtInGetNextFrameReturn>;
+export declare function getDefaultFrameControls<TFrameType, TMediaType>(): Promise<IFrameControls<TFrameType, TMediaType>>;

package/liveness/utils/getNextFrame.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.builtInGetNextFrame = void 0;
-async function builtInGetNextFrame() {
+exports.getDefaultFrameControls = void 0;
+async function getDefaultFrameControls() {
     let videoStream;
     let videoElement;
     let canvasElement;
@@ -25,7 +25,7 @@ async function builtInGetNextFrame() {
             throw new Error('Cannot found video element');
         }
     }
-    function stopGetNextFrame() {
+    function stopGettingFrames() {
         if (videoElement) {
             document.body.removeChild(videoElement);
             videoElement = undefined;
@@ -36,25 +36,30 @@ async function builtInGetNextFrame() {
         if (canvasContext) {
             canvasContext = undefined;
         }
-        videoStream === null || videoStream === void 0 ? void 0 : videoStream.getTracks().forEach(track => { track.stop(); });
-        videoStream = undefined;
+        if (videoStream) {
+            videoStream === null || videoStream === void 0 ? void 0 : videoStream.getTracks().forEach(track => { track.stop(); });
+            videoStream = undefined;
+        }
     }
-    if (!videoStream || !videoElement || !canvasElement) {
-        videoStream = await navigator.mediaDevices.getUserMedia({ video: true });
-        videoElement = document.createElement('video');
-        videoElement.setAttribute('autoplay', 'true');
-        videoElement.style.transform = 'scale(-1, 1)';
-        videoElement.style.position = 'absolute';
-        videoElement.style.left = '99999px';
-        document.body.appendChild(videoElement);
-        videoElement.srcObject = videoStream;
-        canvasElement = document.createElement('canvas');
-        canvasContext = canvasElement.getContext('2d');
+    async function startGettingFrames() {
+        if (!videoStream || !videoElement || !canvasElement) {
+            videoStream = await navigator.mediaDevices.getUserMedia({ video: true });
+            videoElement = document.createElement('video');
+            videoElement.setAttribute('autoplay', 'true');
+            videoElement.style.transform = 'scale(-1, 1)';
+            videoElement.style.position = 'absolute';
+            videoElement.style.left = '99999px';
+            document.body.appendChild(videoElement);
+            videoElement.srcObject = videoStream;
+            canvasElement = document.createElement('canvas');
+            canvasContext = canvasElement.getContext('2d');
+        }
+        return videoStream;
     }
     return {
+        startGettingFrames,
         getNextFrame,
-        stopGetNextFrame,
-        videoStream,
+        stopGettingFrames,
     };
 }
-exports.builtInGetNextFrame = builtInGetNextFrame;
+exports.getDefaultFrameControls = getDefaultFrameControls;

package/liveness/utils/index.d.ts

@@ -1,2 +1,2 @@
-export declare function decodeJwt(token: string): any;
-export declare function tryDecodeJwt(token: string): any;
+export declare function decodeJwt<TDecodeReturnType = any>(token: string): TDecodeReturnType;
+export declare function tryDecodeJwt<TDecodeReturnType = any>(token: string): TDecodeReturnType | null;

package/node/liveness/index.d.ts

@@ -1,8 +1,6 @@
 import { livenessDetection } from './methods/livenessDetection';
 import { uploadIdentificationDocument } from './methods/uploadIdentificationDocument';
-export { livenessDetection } from './methods/livenessDetection';
-export { uploadIdentificationDocument } from './methods/uploadIdentificationDocument';
-export * from './utils/types';
+export { livenessDetection, uploadIdentificationDocument, };
 export default class SantoiDSDK {
     static livenessDetection: typeof livenessDetection;
     static uploadIdentificationDocument: typeof uploadIdentificationDocument;

package/node/liveness/index.js

@@ -1,27 +1,10 @@
 "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 });
 exports.uploadIdentificationDocument = exports.livenessDetection = void 0;
 const livenessDetection_1 = require("./methods/livenessDetection");
+Object.defineProperty(exports, "livenessDetection", { enumerable: true, get: function () { return livenessDetection_1.livenessDetection; } });
 const uploadIdentificationDocument_1 = require("./methods/uploadIdentificationDocument");
-var livenessDetection_2 = require("./methods/livenessDetection");
-Object.defineProperty(exports, "livenessDetection", { enumerable: true, get: function () { return livenessDetection_2.livenessDetection; } });
-var uploadIdentificationDocument_2 = require("./methods/uploadIdentificationDocument");
-Object.defineProperty(exports, "uploadIdentificationDocument", { enumerable: true, get: function () { return uploadIdentificationDocument_2.uploadIdentificationDocument; } });
-__exportStar(require("./utils/types"), exports);
+Object.defineProperty(exports, "uploadIdentificationDocument", { enumerable: true, get: function () { return uploadIdentificationDocument_1.uploadIdentificationDocument; } });
 class SantoiDSDK {
 }
 SantoiDSDK.livenessDetection = livenessDetection_1.livenessDetection;

package/node/liveness/methods/livenessDetection/Service.d.ts

@@ -0,0 +1,6 @@
+import { LivenessDetectionService } from '../../../../liveness/methods/livenessDetection/Service';
+import { type ISDKOptions } from '../../../../utils/types';
+export declare class NodeLivenessDetectionService<TFrameType, TMediaType> extends LivenessDetectionService<TFrameType, TMediaType> {
+    options: ISDKOptions<TFrameType, TMediaType>;
+    onConnect(): Promise<void>;
+}

package/node/liveness/methods/livenessDetection/Service.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeLivenessDetectionService = void 0;
+const Service_1 = require("../../../../liveness/methods/livenessDetection/Service");
+const constants_1 = require("../../../../utils/constants");
+const utils_1 = require("../../../../utils");
+class NodeLivenessDetectionService extends Service_1.LivenessDetectionService {
+    async onConnect() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.frameGetControls.startGettingFrames = this.options.startGettingFrames;
+        this.frameGetControls.getNextFrame = this.options.getNextFrame;
+        this.frameGetControls.stopGettingFrames = this.options.stopGettingFrames;
+        await ((_b = (_a = this.options).startGettingFrames) === null || _b === void 0 ? void 0 : _b.call(_a));
+        await ((_d = (_c = this.options).onStart) === null || _d === void 0 ? void 0 : _d.call(_c));
+        await ((_f = (_e = this.options).onNextStep) === null || _f === void 0 ? void 0 : _f.call(_e, 'front'));
+        await ((_h = (_g = this.options).onFrontStep) === null || _h === void 0 ? void 0 : _h.call(_g));
+        this.cancelSendingFramesToWebsocket = (0, utils_1.callEveryXSeconds)(async () => { await this.sendFramesToWebSocket(); }, constants_1.SEND_FRAMES_INTERVAL_MS);
+    }
+}
+exports.NodeLivenessDetectionService = NodeLivenessDetectionService;

package/node/liveness/methods/livenessDetection/index.d.ts

@@ -0,0 +1,13 @@
+import { type Data } from 'ws';
+import { type ISDKOptions } from '../../../../utils/types';
+export type TFrameType = Data;
+export type TMediaType = undefined;
+type ILivenessDetectionParams = Omit<ISDKOptions<TFrameType, TMediaType>, 'onStart'> & {
+    onStart?: () => void | Promise<void>;
+};
+export declare function livenessDetection(options: ILivenessDetectionParams): {
+    stopLivenessDetection: () => Promise<void>;
+    resumeGettingFrames: () => void;
+    pauseGettingFrames: () => void;
+};
+export {};

package/node/liveness/methods/livenessDetection/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.livenessDetection = void 0;
+const ws_1 = __importDefault(require("ws"));
+const error_1 = require("../../../../utils/error");
+const websocket_1 = require("../../../../utils/websocket");
+const index_1 = require("../../utils/index");
+const Service_1 = require("./Service");
+function livenessDetection(options) {
+    var _a;
+    try {
+        const abstractWebSocket = new websocket_1.AbstractWebSocket({ WebSocketClass: (_a = options.CustomWebSocketClass) !== null && _a !== void 0 ? _a : ws_1.default, decodeJwt: index_1.decodeJwt }, options);
+        abstractWebSocket.startConnection();
+        const livenessDetectionHandler = new Service_1.NodeLivenessDetectionService(options, abstractWebSocket);
+        void abstractWebSocket.waitForWebSocketConnection()
+            .then(() => { void livenessDetectionHandler.onConnect(); })
+            .catch(() => { void livenessDetectionHandler.onError(); });
+        abstractWebSocket.addListener('message', (data) => {
+            void livenessDetectionHandler.onWebSocketMessage({ data: Buffer.from(data).toString() });
+        });
+        abstractWebSocket.addListener('error', () => {
+            void livenessDetectionHandler.onError();
+        });
+        abstractWebSocket.addListener('close', () => {
+            void livenessDetectionHandler.onError();
+        });
+        return {
+            stopLivenessDetection: async () => {
+                await livenessDetectionHandler.stopLivenessDetection();
+            },
+            resumeGettingFrames: () => {
+                livenessDetectionHandler.resumeGettingFrames();
+            },
+            pauseGettingFrames: () => {
+                livenessDetectionHandler.pauseGettingFrames();
+            },
+        };
+    }
+    catch (err) {
+        throw new error_1.SDKError({ message: 'Error while starting SDK', code: error_1.EDefaultErrorCodes.INITIALIZATION_ERROR });
+    }
+}
+exports.livenessDetection = livenessDetection;

package/node/liveness/methods/uploadIdentificationDocument/Service.d.ts

@@ -0,0 +1,4 @@
+import { UploadIdentificationDocumentService, type IServiceOptions, type IInternalServiceOptions } from '../../../../liveness/methods/uploadIdentificationDocument/Service';
+export declare class NodeUploadIdentificationDocumentService<TFrameType, TMediaType, TFileType> extends UploadIdentificationDocumentService<TFrameType, TMediaType, TFileType> {
+    constructor(options: IServiceOptions<TFrameType, TMediaType, TFileType>, internalOptions: IInternalServiceOptions<TFrameType, TMediaType>);
+}

package/node/liveness/methods/uploadIdentificationDocument/Service.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeUploadIdentificationDocumentService = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const Service_1 = require("../../../../liveness/methods/uploadIdentificationDocument/Service");
+const TypificationService_1 = require("../../../../api/TypificationService");
+const FaceMatchService_1 = require("../../../../api/FaceMatchService");
+const index_1 = require("../../utils/index");
+class NodeUploadIdentificationDocumentService extends Service_1.UploadIdentificationDocumentService {
+    constructor(options, internalOptions) {
+        super(options, internalOptions);
+        this.typificationService = new TypificationService_1.TypificationService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
+        this.faceMatchService = new FaceMatchService_1.FaceMatchService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
+    }
+}
+exports.NodeUploadIdentificationDocumentService = NodeUploadIdentificationDocumentService;

package/node/liveness/methods/uploadIdentificationDocument/index.d.ts

@@ -0,0 +1,25 @@
+import { type Data } from 'ws';
+import { type IServiceOptions } from '../../../../liveness/methods/uploadIdentificationDocument/Service';
+import { type TFrameType, type TMediaType } from '../livenessDetection';
+type TFileType = Data;
+export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType, TMediaType, TFileType>): {
+    startDocumentUpload: (file: Data) => Promise<void>;
+    startLivenessDetection: (startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<Data, undefined>, "token" | "track"> & {
+        track?: string | undefined;
+        token?: string | undefined;
+    }) | undefined) => (Omit<{
+        getVideoStream: () => import("../../../../liveness/methods/livenessDetection").TMediaType;
+        stopLivenessDetection: () => Promise<void>;
+        resumeGettingFrames: () => void;
+        pauseGettingFrames: () => void;
+    }, "getVideoStream"> & {
+        getVideoStream?: (() => undefined) | undefined;
+    }) | undefined;
+    startFaceComparison: () => Promise<void>;
+    startAll: (file: Data, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<Data, undefined>, "token" | "track"> & {
+        track?: string | undefined;
+        token?: string | undefined;
+    }) | undefined) => void;
+    getResults: () => import("../../../../liveness/methods/uploadIdentificationDocument/Service").IUploadIdentificationDocumentResults<Data>;
+};
+export {};

package/node/liveness/methods/uploadIdentificationDocument/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadIdentificationDocument = void 0;
+const Service_1 = require("./Service");
+const livenessDetection_1 = require("../livenessDetection");
+function uploadIdentificationDocument(options) {
+    const uploadIdentificationDocumentService = new Service_1.NodeUploadIdentificationDocumentService(options, {
+        livenessDetection: livenessDetection_1.livenessDetection,
+    });
+    return {
+        startDocumentUpload: async (...rest) => {
+            await uploadIdentificationDocumentService.startDocumentUpload(...rest);
+        },
+        startLivenessDetection: (...rest) => {
+            return uploadIdentificationDocumentService.startLivenessDetection(...rest);
+        },
+        startFaceComparison: async (...rest) => {
+            await uploadIdentificationDocumentService.tryStartFaceMatch(...rest);
+        },
+        startAll: (...rest) => {
+            uploadIdentificationDocumentService.startAll(...rest);
+        },
+        getResults: (...rest) => {
+            return uploadIdentificationDocumentService.getResults(...rest);
+        },
+    };
+}
+exports.uploadIdentificationDocument = uploadIdentificationDocument;

package/node/liveness/utils/index.d.ts

@@ -1,2 +1,2 @@
-export declare function decodeJwt(token: string): any;
-export declare function tryDecodeJwt(token: string): any;
+export declare function decodeJwt<TDecodeReturnType = any>(token: string): TDecodeReturnType;
+export declare function tryDecodeJwt<TDecodeReturnType = any>(token: string): TDecodeReturnType | null;

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "santoid-sdk",
-  "version": "2.0.2",
+  "version": "3.0.0",
   "description": "",
   "main": "liveness/index.js",
   "types": "liveness/index.d.ts",
   "scripts": {
     "expose:cmd": "mv -v dist/* ./ && rm -rf ./dist",
-    "build:clear": "rm -rf ./browser ./liveness ./node ./utils ./index.js ./index.d.ts ./dist",
+    "build:clear": "rm -rf ./browser ./api ./liveness ./node ./utils ./index.js ./index.d.ts ./dist",
     "build:webpack": "webpack --mode=production",
     "build:typescript": "npm run build:clear && tsc -p tsconfig.prod.json",
     "build": "npm run build:typescript && npm run build:webpack && npm run expose:cmd",
-    "test": "jest --coverage false",
+    "test": "jest --coverage false --runInBand",
     "test:coverage": "jest --coverage --runInBand"
   },
   "keywords": [],

package/utils/error.d.ts

@@ -0,0 +1,24 @@
+export declare enum EDefaultErrorCodes {
+    INITIALIZATION_ERROR = "initialization-error",
+    INTERNAL_ERROR = "internal-error"
+}
+export declare enum ELivenessDetectionErrorCodes {
+    WRONG_POSITION = "liveness-detection/wrong-position"
+}
+export declare enum EUploadIdentificationDocumentErrorCodes {
+    FACE_MATCH_ERROR = "upload-identification-document/face-match-error",
+    FACE_MATCH_UNAVAILABLE_FACES_ERROR = "upload-identification-document/face-match-unavailable-faces-error",
+    TYPIFICATION_ERROR = "upload-identification-document/typification-error",
+    LIVENESS_DETECTION_ERROR = "upload-identification-document/liveness-detection-error"
+}
+interface ISDKErrorConstructorParams {
+    message: string;
+    code: EDefaultErrorCodes | ELivenessDetectionErrorCodes | EUploadIdentificationDocumentErrorCodes;
+    details?: any;
+}
+export declare class SDKError extends Error {
+    code: string;
+    details?: any;
+    constructor({ message, code, details }: ISDKErrorConstructorParams);
+}
+export {};

package/utils/error.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKError = exports.EUploadIdentificationDocumentErrorCodes = exports.ELivenessDetectionErrorCodes = exports.EDefaultErrorCodes = void 0;
+var EDefaultErrorCodes;
+(function (EDefaultErrorCodes) {
+    EDefaultErrorCodes["INITIALIZATION_ERROR"] = "initialization-error";
+    EDefaultErrorCodes["INTERNAL_ERROR"] = "internal-error";
+})(EDefaultErrorCodes || (exports.EDefaultErrorCodes = EDefaultErrorCodes = {}));
+var ELivenessDetectionErrorCodes;
+(function (ELivenessDetectionErrorCodes) {
+    ELivenessDetectionErrorCodes["WRONG_POSITION"] = "liveness-detection/wrong-position";
+})(ELivenessDetectionErrorCodes || (exports.ELivenessDetectionErrorCodes = ELivenessDetectionErrorCodes = {}));
+var EUploadIdentificationDocumentErrorCodes;
+(function (EUploadIdentificationDocumentErrorCodes) {
+    EUploadIdentificationDocumentErrorCodes["FACE_MATCH_ERROR"] = "upload-identification-document/face-match-error";
+    EUploadIdentificationDocumentErrorCodes["FACE_MATCH_UNAVAILABLE_FACES_ERROR"] = "upload-identification-document/face-match-unavailable-faces-error";
+    EUploadIdentificationDocumentErrorCodes["TYPIFICATION_ERROR"] = "upload-identification-document/typification-error";
+    EUploadIdentificationDocumentErrorCodes["LIVENESS_DETECTION_ERROR"] = "upload-identification-document/liveness-detection-error";
+})(EUploadIdentificationDocumentErrorCodes || (exports.EUploadIdentificationDocumentErrorCodes = EUploadIdentificationDocumentErrorCodes = {}));
+class SDKError extends Error {
+    constructor({ message, code, details }) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}
+exports.SDKError = SDKError;

package/utils/index.d.ts

@@ -0,0 +1,7 @@
+import { type TCallbackFunction } from './types';
+export declare const wait: (ms: number) => Promise<void>;
+export declare function waitFor(conditionFn: TCallbackFunction): Promise<void>;
+export declare function callEveryXSeconds(fn: () => Promise<any>, xSeconds: number, baseConfig?: {
+    stop: boolean;
+}): () => void;
+export declare function capitalizeFirstLetter(str: string): string;

package/utils/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalizeFirstLetter = exports.callEveryXSeconds = exports.waitFor = exports.wait = void 0;
+const wait = async (ms) => {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+exports.wait = wait;
+async function waitFor(conditionFn) {
+    await new Promise((resolve) => {
+        if (conditionFn()) {
+            resolve();
+        }
+        else {
+            setTimeout(() => {
+                void waitFor(conditionFn).then(resolve);
+            }, 500);
+        }
+    });
+}
+exports.waitFor = waitFor;
+function callEveryXSeconds(fn, xSeconds, baseConfig = { stop: false }) {
+    const temporaryConfig = { timerEnd: false };
+    setTimeout(() => {
+        temporaryConfig.timerEnd = true;
+    }, xSeconds);
+    void fn()
+        .then(async () => {
+        await waitFor(() => temporaryConfig.timerEnd);
+        if (!baseConfig.stop) {
+            callEveryXSeconds(fn, xSeconds, baseConfig);
+        }
+    });
+    function unsubscribe() {
+        baseConfig.stop = true;
+    }
+    return unsubscribe;
+}
+exports.callEveryXSeconds = callEveryXSeconds;
+function capitalizeFirstLetter(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+exports.capitalizeFirstLetter = capitalizeFirstLetter;