santoid-sdk 5.1.0 → 5.3.0

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

@@ -1,8 +1,8 @@
 "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 ApiTypificationService_1 = require("../../../../api/ApiTypificationService");
+const ApiFaceMatchService_1 = require("../../../../api/ApiFaceMatchService");
 const error_1 = require("../../../../utils/error");
 const uuid_1 = require("uuid");
 const index_1 = require("../../utils/index");
@@ -16,8 +16,8 @@ class UploadIdentificationDocumentService {
         };
         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 });
+        this.typificationService = new ApiTypificationService_1.ApiTypificationService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
+        this.faceMatchService = new ApiFaceMatchService_1.ApiFaceMatchService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
     }
     getResults() {
         return this.results;
@@ -73,6 +73,34 @@ class UploadIdentificationDocumentService {
             }, 5000);
         });
     }
+    async waitForResultsFaceMatch(requestId) {
+        return await new Promise((resolve, reject) => {
+            const interval = setInterval(async () => {
+                var _a, _b, _c, _d;
+                try {
+                    (_b = (_a = this.options).onClearInterval) === null || _b === void 0 ? void 0 : _b.call(_a, interval);
+                    const data = await this.faceMatchService.get(requestId);
+                    if ((data === null || data === void 0 ? void 0 : data.status) === 'error' || (data === null || data === void 0 ? void 0 : data.status) === 'error_connector') {
+                        clearInterval(interval);
+                        reject(new Error('Não foi possível processar os resultados do FaceMatch'));
+                    }
+                    else if ((data === null || data === void 0 ? void 0 : data.status) === 'processed' && data.fileURL) {
+                        const response = await fetch(data.fileURL);
+                        let faceMatchResults = await response.json();
+                        faceMatchResults = Object.assign(Object.assign({}, faceMatchResults), { fileImage1: (_c = data.fileImage1) !== null && _c !== void 0 ? _c : '', fileImage2: (_d = data.fileImage2) !== null && _d !== void 0 ? _d : '' });
+                        if (faceMatchResults) {
+                            clearInterval(interval);
+                            resolve(faceMatchResults);
+                        }
+                    }
+                }
+                catch (error) {
+                    clearInterval(interval);
+                    reject(new Error(error));
+                }
+            }, 5000);
+        });
+    }
     async startDocumentUpload(file) {
         var _a, _b;
         try {
@@ -86,6 +114,7 @@ class UploadIdentificationDocumentService {
             const adaptedError = new error_1.SDKError({
                 message: 'Error during document upload/analysis',
                 code: error_1.EUploadIdentificationDocumentErrorCodes.DOCUMENT_ANALYSIS_ERROR,
+                fatal: false,
                 details: err,
             });
             await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, adaptedError));
@@ -126,6 +155,7 @@ class UploadIdentificationDocumentService {
             const adaptedError = new error_1.SDKError({
                 message: 'Error during liveness detection',
                 code: error_1.EUploadIdentificationDocumentErrorCodes.LIVENESS_DETECTION_ERROR,
+                fatal: false,
                 details: err,
             });
             (_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, adaptedError);
@@ -136,13 +166,15 @@ class UploadIdentificationDocumentService {
         var _a, _b;
         try {
             this.updateResults({ faceMatch: { status: null, results: null, loading: true, error: null } });
-            const faceMatchResults = await this.faceMatchService.faceMatch(firstImage, secondImage);
+            const { requestId } = await this.faceMatchService.faceMatch(firstImage, secondImage, `sdk-facematch-${(0, uuid_1.v4)()}`);
+            const faceMatchResults = await this.waitForResultsFaceMatch(requestId);
             this.updateResults({ faceMatch: { results: faceMatchResults, status: 'success', loading: false, error: null } });
         }
         catch (err) {
             const adaptedError = new error_1.SDKError({
                 message: 'Error when comparing the face with the document',
                 code: error_1.EUploadIdentificationDocumentErrorCodes.FACE_MATCH_ERROR,
+                fatal: false,
                 details: err,
             });
             await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, adaptedError));
@@ -162,6 +194,7 @@ class UploadIdentificationDocumentService {
             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,
+                fatal: false,
             })));
         }
     }

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

@@ -1,8 +1,7 @@
 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>;
+export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType, TMediaType>): {
+    startDocumentUpload: (file: TFrameType) => Promise<void>;
     startLivenessDetection: (startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
         track?: string | undefined;
         token?: string | undefined;
@@ -15,10 +14,9 @@ export declare function uploadIdentificationDocument(options: IServiceOptions<TF
         getVideoStream?: (() => TMediaType) | undefined;
     }) | undefined;
     startFaceComparison: () => Promise<void>;
-    startAll: (file: TFileType, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
+    startAll: (file: TFrameType, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "token" | "track"> & {
         track?: string | undefined;
         token?: string | undefined;
     }) | undefined) => void;
-    getResults: () => import("./Service").IUploadIdentificationDocumentResults<TFileType>;
+    getResults: () => import("./Service").IUploadIdentificationDocumentResults<TFrameType>;
 };
-export {};

package/client/liveness/utils/getNextFrame.js

@@ -43,12 +43,17 @@ async function getDefaultFrameControls() {
     }
     async function startGettingFrames() {
         if (!videoStream || !videoElement || !canvasElement) {
-            videoStream = await navigator.mediaDevices.getUserMedia({ video: true });
+            videoStream = await navigator.mediaDevices.getUserMedia({
+                audio: false,
+                video: {
+                    facingMode: 'environment',
+                },
+            });
             videoElement = document.createElement('video');
             videoElement.setAttribute('autoplay', 'true');
             videoElement.style.transform = 'scale(-1, 1)';
             videoElement.style.position = 'absolute';
-            videoElement.style.left = '99999px';
+            videoElement.style.left = '-99999px';
             document.body.appendChild(videoElement);
             videoElement.srcObject = videoStream;
             canvasElement = document.createElement('canvas');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "santoid-sdk",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "description": "",
   "main": "client/index.js",
   "types": "client/index.d.ts",

package/server/core/index.d.ts

@@ -0,0 +1,4 @@
+import { typification } from './methods/typification';
+import { faceMatch } from './methods/faceMatch';
+import { ocr } from './methods/ocr';
+export { typification, faceMatch, ocr, };

package/server/core/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ocr = exports.faceMatch = exports.typification = void 0;
+const typification_1 = require("./methods/typification");
+Object.defineProperty(exports, "typification", { enumerable: true, get: function () { return typification_1.typification; } });
+const faceMatch_1 = require("./methods/faceMatch");
+Object.defineProperty(exports, "faceMatch", { enumerable: true, get: function () { return faceMatch_1.faceMatch; } });
+const ocr_1 = require("./methods/ocr");
+Object.defineProperty(exports, "ocr", { enumerable: true, get: function () { return ocr_1.ocr; } });

package/server/core/methods/faceMatch/Service.d.ts

@@ -0,0 +1,9 @@
+import { FaceMatchService, type TFaceMatchServiceOptions } from '../../../../client/core/methods/faceMatch/Service';
+export type TNodeFaceMatchServiceOptions<TMediaType> = Omit<TFaceMatchServiceOptions<TMediaType>, 'onStart'> & {
+    onStart?: () => void | Promise<void>;
+};
+export declare class NodeFaceMatchService<TFrameType, TMediaType> extends FaceMatchService<TFrameType, TMediaType> {
+    options: TNodeFaceMatchServiceOptions<TMediaType>;
+    constructor(options: TNodeFaceMatchServiceOptions<TMediaType>);
+    initialize(file1?: TFrameType, file2?: TFrameType): Promise<void>;
+}

package/server/core/methods/faceMatch/Service.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeFaceMatchService = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const Service_1 = require("../../../../client/core/methods/faceMatch/Service");
+const ApiFaceMatchService_1 = require("../../../../api/ApiFaceMatchService");
+const index_1 = require("../../../liveness/utils/index");
+class NodeFaceMatchService extends Service_1.FaceMatchService {
+    constructor(options) {
+        super(options);
+        this.service = new ApiFaceMatchService_1.ApiFaceMatchService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
+    }
+    async initialize(file1, file2) {
+        if (file1) {
+            // Start processing immediately
+            this.startProcessing(file1, file2);
+        }
+    }
+}
+exports.NodeFaceMatchService = NodeFaceMatchService;

package/server/core/methods/faceMatch/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { type TNodeFaceMatchServiceOptions } from './Service';
+export type TFrameType = string | Buffer | ArrayBuffer | Buffer;
+export type TMediaType = undefined;
+export declare function faceMatch(options: TNodeFaceMatchServiceOptions<TMediaType>, file1?: TFrameType, file2?: TFrameType): Promise<{
+    sendFiles: (file1: TFrameType, file2?: TFrameType | undefined) => Promise<void>;
+}>;

package/server/core/methods/faceMatch/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.faceMatch = void 0;
+const error_1 = require("../../../../utils/error");
+const Service_1 = require("./Service");
+async function faceMatch(options, file1, file2) {
+    var _a, _b;
+    try {
+        const service = new Service_1.NodeFaceMatchService(options);
+        await service.initialize(file1, file2);
+        await ((_b = (_a = service.options).onStart) === null || _b === void 0 ? void 0 : _b.call(_a));
+        // Methods are exported like this to prevent the value of "this" from changing
+        return {
+            sendFiles: async (...rest) => {
+                await service.startProcessing(...rest);
+            },
+        };
+    }
+    catch (err) {
+        throw new error_1.SDKError({
+            message: 'Error while starting SDK',
+            code: error_1.EDefaultErrorCodes.INITIALIZATION_ERROR,
+            fatal: true,
+            details: err,
+        });
+    }
+}
+exports.faceMatch = faceMatch;

package/server/core/methods/ocr/Service.d.ts

@@ -0,0 +1,9 @@
+import { OcrService, type TOcrServiceOptions } from '../../../../client/core/methods/ocr/Service';
+export type TNodeOcrServiceOptions<TMediaType> = Omit<TOcrServiceOptions<TMediaType>, 'onStart'> & {
+    onStart?: () => void | Promise<void>;
+};
+export declare class NodeOcrService<TFrameType, TMediaType> extends OcrService<TFrameType, TMediaType> {
+    options: TNodeOcrServiceOptions<TMediaType>;
+    constructor(options: TNodeOcrServiceOptions<TMediaType>);
+    initialize(file?: TFrameType): Promise<void>;
+}

package/server/core/methods/ocr/Service.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeOcrService = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const Service_1 = require("../../../../client/core/methods/ocr/Service");
+const ApiOcrService_1 = require("../../../../api/ApiOcrService");
+const index_1 = require("../../../liveness/utils/index");
+class NodeOcrService extends Service_1.OcrService {
+    constructor(options) {
+        super(options);
+        this.service = new ApiOcrService_1.ApiOcrService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
+    }
+    async initialize(file) {
+        if (file) {
+            // Start processing immediately
+            this.startProcessing(file);
+        }
+    }
+}
+exports.NodeOcrService = NodeOcrService;

package/server/core/methods/ocr/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { type TNodeOcrServiceOptions } from './Service';
+export type TFrameType = string | Buffer | ArrayBuffer | Buffer;
+export type TMediaType = undefined;
+export declare function ocr(options: TNodeOcrServiceOptions<TMediaType>, file?: TFrameType): Promise<{
+    sendFile: (file: TFrameType) => Promise<void>;
+}>;

package/server/core/methods/ocr/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ocr = void 0;
+const error_1 = require("../../../../utils/error");
+const Service_1 = require("./Service");
+async function ocr(options, file) {
+    var _a, _b;
+    try {
+        const service = new Service_1.NodeOcrService(options);
+        await service.initialize(file);
+        await ((_b = (_a = service.options).onStart) === null || _b === void 0 ? void 0 : _b.call(_a));
+        // Methods are exported like this to prevent the value of "this" from changing
+        return {
+            sendFile: async (file) => {
+                await service.startProcessing(file);
+            },
+        };
+    }
+    catch (err) {
+        throw new error_1.SDKError({
+            message: 'Error while starting SDK',
+            code: error_1.EDefaultErrorCodes.INITIALIZATION_ERROR,
+            fatal: true,
+            details: err,
+        });
+    }
+}
+exports.ocr = ocr;

package/server/core/methods/typification/Service.d.ts

@@ -0,0 +1,9 @@
+import { TypificationService, type TTypificationServiceOptions } from '../../../../client/core/methods/typification/Service';
+export type TNodeTypificationServiceOptions<TMediaType> = Omit<TTypificationServiceOptions<TMediaType>, 'onStart'> & {
+    onStart?: () => void | Promise<void>;
+};
+export declare class NodeTypificationService<TFrameType, TMediaType> extends TypificationService<TFrameType, TMediaType> {
+    options: TNodeTypificationServiceOptions<TMediaType>;
+    constructor(options: TNodeTypificationServiceOptions<TMediaType>);
+    initialize(file?: TFrameType): Promise<void>;
+}

package/server/core/methods/typification/Service.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTypificationService = void 0;
+const form_data_1 = __importDefault(require("form-data"));
+const Service_1 = require("../../../../client/core/methods/typification/Service");
+const ApiTypificationService_1 = require("../../../../api/ApiTypificationService");
+const index_1 = require("../../../liveness/utils/index");
+class NodeTypificationService extends Service_1.TypificationService {
+    constructor(options) {
+        super(options);
+        this.service = new ApiTypificationService_1.ApiTypificationService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
+    }
+    async initialize(file) {
+        if (file) {
+            // Start processing immediately
+            this.startProcessing(file);
+        }
+    }
+}
+exports.NodeTypificationService = NodeTypificationService;

package/server/core/methods/typification/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { type TNodeTypificationServiceOptions } from './Service';
+export type TFrameType = string | Buffer | ArrayBuffer | Buffer;
+export type TMediaType = undefined;
+export declare function typification(options: TNodeTypificationServiceOptions<TMediaType>, file?: TFrameType): Promise<{
+    sendFile: (file: TFrameType) => Promise<void>;
+}>;

package/server/core/methods/typification/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typification = void 0;
+const error_1 = require("../../../../utils/error");
+const Service_1 = require("./Service");
+async function typification(options, file) {
+    var _a, _b;
+    try {
+        const service = new Service_1.NodeTypificationService(options);
+        await service.initialize(file);
+        await ((_b = (_a = service.options).onStart) === null || _b === void 0 ? void 0 : _b.call(_a));
+        // Methods are exported like this to prevent the value of "this" from changing
+        return {
+            sendFile: async (file) => {
+                await service.startProcessing(file);
+            },
+        };
+    }
+    catch (err) {
+        throw new error_1.SDKError({
+            message: 'Error while starting SDK',
+            code: error_1.EDefaultErrorCodes.INITIALIZATION_ERROR,
+            fatal: true,
+            details: err,
+        });
+    }
+}
+exports.typification = typification;

package/server/index.d.ts

@@ -1,6 +1,12 @@
 import { livenessDetection } from './liveness/methods/livenessDetection';
 import { uploadIdentificationDocument } from './liveness/methods/uploadIdentificationDocument';
+import { typification } from './core/methods/typification';
+import { faceMatch } from './core/methods/faceMatch';
+import { ocr } from './core/methods/ocr';
 export default class SantoiDSDK {
     static readonly livenessDetection: typeof livenessDetection;
     static readonly uploadIdentificationDocument: typeof uploadIdentificationDocument;
+    static readonly typification: typeof typification;
+    static readonly faceMatch: typeof faceMatch;
+    static readonly ocr: typeof ocr;
 }

package/server/index.js

@@ -2,8 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const livenessDetection_1 = require("./liveness/methods/livenessDetection");
 const uploadIdentificationDocument_1 = require("./liveness/methods/uploadIdentificationDocument");
+const typification_1 = require("./core/methods/typification");
+const faceMatch_1 = require("./core/methods/faceMatch");
+const ocr_1 = require("./core/methods/ocr");
 class SantoiDSDK {
 }
 SantoiDSDK.livenessDetection = livenessDetection_1.livenessDetection;
 SantoiDSDK.uploadIdentificationDocument = uploadIdentificationDocument_1.uploadIdentificationDocument;
+SantoiDSDK.typification = typification_1.typification;
+SantoiDSDK.faceMatch = faceMatch_1.faceMatch;
+SantoiDSDK.ocr = ocr_1.ocr;
 exports.default = SantoiDSDK;

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

@@ -40,7 +40,11 @@ function livenessDetection(options) {
         };
     }
     catch (err) {
-        throw new error_1.SDKError({ message: 'Error while starting SDK', code: error_1.EDefaultErrorCodes.INITIALIZATION_ERROR });
+        throw new error_1.SDKError({
+            message: 'Error while starting SDK',
+            code: error_1.EDefaultErrorCodes.INITIALIZATION_ERROR,
+            fatal: true,
+        });
     }
 }
 exports.livenessDetection = livenessDetection;

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

@@ -1,4 +1,4 @@
 import { UploadIdentificationDocumentService, type IServiceOptions, type IInternalServiceOptions } from '../../../../client/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>);
+export declare class NodeUploadIdentificationDocumentService<TFrameType, TMediaType> extends UploadIdentificationDocumentService<TFrameType, TMediaType> {
+    constructor(options: IServiceOptions<TFrameType, TMediaType>, internalOptions: IInternalServiceOptions<TFrameType, TMediaType>);
 }

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

@@ -6,14 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeUploadIdentificationDocumentService = void 0;
 const form_data_1 = __importDefault(require("form-data"));
 const Service_1 = require("../../../../client/liveness/methods/uploadIdentificationDocument/Service");
-const TypificationService_1 = require("../../../../api/TypificationService");
-const FaceMatchService_1 = require("../../../../api/FaceMatchService");
+const ApiTypificationService_1 = require("../../../../api/ApiTypificationService");
+const ApiFaceMatchService_1 = require("../../../../api/ApiFaceMatchService");
 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 });
+        this.typificationService = new ApiTypificationService_1.ApiTypificationService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
+        this.faceMatchService = new ApiFaceMatchService_1.ApiFaceMatchService(options, { FormDataClass: form_data_1.default, tryDecodeJwt: index_1.tryDecodeJwt });
     }
 }
 exports.NodeUploadIdentificationDocumentService = NodeUploadIdentificationDocumentService;

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

@@ -1,10 +1,9 @@
-import { type Data } from 'ws';
+/// <reference types="ws" />
 import { type IServiceOptions } from '../../../../client/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"> & {
+export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType, TMediaType>): {
+    startDocumentUpload: (file: import("ws").Data) => Promise<void>;
+    startLivenessDetection: (startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<import("ws").Data, undefined>, "token" | "track"> & {
         track?: string | undefined;
         token?: string | undefined;
     }) | undefined) => (Omit<{
@@ -16,10 +15,9 @@ export declare function uploadIdentificationDocument(options: IServiceOptions<TF
         getVideoStream?: (() => undefined) | undefined;
     }) | undefined;
     startFaceComparison: () => Promise<void>;
-    startAll: (file: Data, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<Data, undefined>, "token" | "track"> & {
+    startAll: (file: import("ws").Data, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<import("ws").Data, undefined>, "token" | "track"> & {
         track?: string | undefined;
         token?: string | undefined;
     }) | undefined) => void;
-    getResults: () => import("../../../../client/liveness/methods/uploadIdentificationDocument/Service").IUploadIdentificationDocumentResults<Data>;
+    getResults: () => import("../../../../client/liveness/methods/uploadIdentificationDocument/Service").IUploadIdentificationDocumentResults<import("ws").Data>;
 };
-export {};

package/utils/error.d.ts

@@ -11,14 +11,31 @@ export declare enum EUploadIdentificationDocumentErrorCodes {
     DOCUMENT_ANALYSIS_ERROR = "upload-identification-document/document-analysis-error",
     LIVENESS_DETECTION_ERROR = "upload-identification-document/liveness-detection-error"
 }
+export declare enum EFaceMatchErrorCodes {
+    FIRST_IMAGE_NOT_SELECTED = "face-match/first-image-not-selected"
+}
+export declare enum ECameraErrorCodes {
+    INITIALIZATION_ERROR = "camera/initialization-error",
+    IS_RUNNING = "camera/is-running",
+    ALREADY_STARTED = "camera/already-started",
+    NOT_INITIALIZED = "camera/not-initialized",
+    CANNOT_CAPTURE_IMAGE = "camera/cannot-capture-image",
+    SHUTDOWN_ERROR = "camera/shutdown-error"
+}
+export declare enum EProcessingErrorCodes {
+    PROCESSING_ERROR = "processing/processing-error",
+    ALREADY_STARTED = "processing/already-started"
+}
 interface ISDKErrorConstructorParams {
     message: string;
-    code: EDefaultErrorCodes | ELivenessDetectionErrorCodes | EUploadIdentificationDocumentErrorCodes;
+    code: EDefaultErrorCodes | ELivenessDetectionErrorCodes | EUploadIdentificationDocumentErrorCodes | EFaceMatchErrorCodes | EProcessingErrorCodes | ECameraErrorCodes;
+    fatal: boolean;
     details?: any;
 }
 export declare class SDKError extends Error {
     code: string;
     details?: any;
-    constructor({ message, code, details }: ISDKErrorConstructorParams);
+    fatal: boolean;
+    constructor({ message, code, fatal, details }: ISDKErrorConstructorParams);
 }
 export {};

package/utils/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDKError = exports.EUploadIdentificationDocumentErrorCodes = exports.ELivenessDetectionErrorCodes = exports.EDefaultErrorCodes = void 0;
+exports.SDKError = exports.EProcessingErrorCodes = exports.ECameraErrorCodes = exports.EFaceMatchErrorCodes = exports.EUploadIdentificationDocumentErrorCodes = exports.ELivenessDetectionErrorCodes = exports.EDefaultErrorCodes = void 0;
 var EDefaultErrorCodes;
 (function (EDefaultErrorCodes) {
     EDefaultErrorCodes["INITIALIZATION_ERROR"] = "initialization-error";
@@ -17,10 +17,29 @@ var EUploadIdentificationDocumentErrorCodes;
     EUploadIdentificationDocumentErrorCodes["DOCUMENT_ANALYSIS_ERROR"] = "upload-identification-document/document-analysis-error";
     EUploadIdentificationDocumentErrorCodes["LIVENESS_DETECTION_ERROR"] = "upload-identification-document/liveness-detection-error";
 })(EUploadIdentificationDocumentErrorCodes || (exports.EUploadIdentificationDocumentErrorCodes = EUploadIdentificationDocumentErrorCodes = {}));
+var EFaceMatchErrorCodes;
+(function (EFaceMatchErrorCodes) {
+    EFaceMatchErrorCodes["FIRST_IMAGE_NOT_SELECTED"] = "face-match/first-image-not-selected";
+})(EFaceMatchErrorCodes || (exports.EFaceMatchErrorCodes = EFaceMatchErrorCodes = {}));
+var ECameraErrorCodes;
+(function (ECameraErrorCodes) {
+    ECameraErrorCodes["INITIALIZATION_ERROR"] = "camera/initialization-error";
+    ECameraErrorCodes["IS_RUNNING"] = "camera/is-running";
+    ECameraErrorCodes["ALREADY_STARTED"] = "camera/already-started";
+    ECameraErrorCodes["NOT_INITIALIZED"] = "camera/not-initialized";
+    ECameraErrorCodes["CANNOT_CAPTURE_IMAGE"] = "camera/cannot-capture-image";
+    ECameraErrorCodes["SHUTDOWN_ERROR"] = "camera/shutdown-error";
+})(ECameraErrorCodes || (exports.ECameraErrorCodes = ECameraErrorCodes = {}));
+var EProcessingErrorCodes;
+(function (EProcessingErrorCodes) {
+    EProcessingErrorCodes["PROCESSING_ERROR"] = "processing/processing-error";
+    EProcessingErrorCodes["ALREADY_STARTED"] = "processing/already-started";
+})(EProcessingErrorCodes || (exports.EProcessingErrorCodes = EProcessingErrorCodes = {}));
 class SDKError extends Error {
-    constructor({ message, code, details }) {
+    constructor({ message, code, fatal, details }) {
         super(message);
         this.code = code;
+        this.fatal = fatal;
         this.details = details;
     }
 }

package/utils/types.d.ts

@@ -21,6 +21,7 @@ export type TWebSocketClass<TFrameType> = new (url: string) => IBaseWebSocket<TF
 export interface IBaseSDKOptions {
     token: string;
     track: string;
+    template?: string;
     customId?: string;
     domain?: string;
     customWebSocketUrl?: string;