santoid-sdk 5.2.0 → 5.4.0

package/client/index.js

@@ -3,9 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const livenessDetection_1 = require("./liveness/methods/livenessDetection");
 const uploadIdentificationDocument_1 = require("./liveness/methods/uploadIdentificationDocument");
 const insertUploadIdentificationDocument_1 = require("./embedded/methods/insertUploadIdentificationDocument");
+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.insertUploadIdentificationDocument = insertUploadIdentificationDocument_1.insertUploadIdentificationDocument;
+SantoiDSDK.typification = typification_1.typification;
+SantoiDSDK.ocr = ocr_1.ocr;
+SantoiDSDK.faceMatch = faceMatch_1.faceMatch;
 exports.default = SantoiDSDK;

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

@@ -50,7 +50,11 @@ class LivenessDetectionService {
             await this.stopLivenessDetection();
         }
         if (parsedMessage === null || parsedMessage === void 0 ? void 0 : parsedMessage.error) {
-            await ((_h = (_g = this.options).onError) === null || _h === void 0 ? void 0 : _h.call(_g, new error_1.SDKError({ message: 'Wrong position', code: error_1.ELivenessDetectionErrorCodes.WRONG_POSITION })));
+            await ((_h = (_g = this.options).onError) === null || _h === void 0 ? void 0 : _h.call(_g, new error_1.SDKError({
+                message: 'Wrong position',
+                code: error_1.ELivenessDetectionErrorCodes.WRONG_POSITION,
+                fatal: false,
+            })));
         }
         return parsedMessage;
     }
@@ -112,7 +116,11 @@ class LivenessDetectionService {
     async onError() {
         var _a, _b;
         if (!this.validationSuccess) {
-            await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({ message: 'Internal Error', code: error_1.EDefaultErrorCodes.INTERNAL_ERROR })));
+            await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({
+                message: 'Internal Error',
+                code: error_1.EDefaultErrorCodes.INTERNAL_ERROR,
+                fatal: false,
+            })));
             await this.stopLivenessDetection();
         }
     }

package/client/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/client/liveness/methods/uploadIdentificationDocument/Service.d.ts

@@ -1,29 +1,29 @@
-import { TypificationService, type ITypificationResult } from '../../../../api/TypificationService';
-import { FaceMatchService, type IFaceMatchResult } from '../../../../api/FaceMatchService';
+import { ApiTypificationService, type ITypificationResult } from '../../../../api/ApiTypificationService';
+import { ApiFaceMatchService, type IFaceMatchResult } from '../../../../api/ApiFaceMatchService';
 import { type ILivenessResults, type IBaseSDKOptions, type TCallbackFunction, type ISDKOptions } from '../../../../utils/types';
 import { SDKError } from '../../../../utils/error';
 import { type livenessDetection } from '../livenessDetection';
-export declare class UploadIdentificationDocumentService<TFrameType, TMediaType, TFileType> {
-    options: IServiceOptions<TFrameType, TMediaType, TFileType>;
+export declare class UploadIdentificationDocumentService<TFrameType, TMediaType> {
+    options: IServiceOptions<TFrameType, TMediaType>;
     internalOptions: IInternalServiceOptions<TFrameType, TMediaType>;
-    typificationService: TypificationService<TFileType>;
-    faceMatchService: FaceMatchService<TFileType>;
-    results: IUploadIdentificationDocumentResults<TFileType>;
-    constructor(options: IServiceOptions<TFrameType, TMediaType, TFileType>, internalOptions: IInternalServiceOptions<TFrameType, TMediaType>);
-    getResults(): IUploadIdentificationDocumentResults<TFileType>;
-    updateResults(updatedResults: Partial<IUploadIdentificationDocumentResults<TFileType>>): Promise<void>;
-    updateUploadedDocument(file: TFileType): void;
+    typificationService: ApiTypificationService<TFrameType>;
+    faceMatchService: ApiFaceMatchService<TFrameType>;
+    results: IUploadIdentificationDocumentResults<TFrameType>;
+    constructor(options: IServiceOptions<TFrameType, TMediaType>, internalOptions: IInternalServiceOptions<TFrameType, TMediaType>);
+    getResults(): IUploadIdentificationDocumentResults<TFrameType>;
+    updateResults(updatedResults: Partial<IUploadIdentificationDocumentResults<TFrameType>>): Promise<void>;
+    updateUploadedDocument(file: TFrameType): void;
     waitForResults(requestId: string): Promise<ITypificationResult>;
     waitForResultsFaceMatch(requestId: string): Promise<IFaceMatchResult>;
-    startDocumentUpload(file: TFileType): Promise<void>;
+    startDocumentUpload(file: TFrameType): Promise<void>;
     startLivenessDetection(startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): TLivenessDetectionReturn<TMediaType> | undefined;
-    startFaceMatch(firstImage: TFileType, secondImage: TFileType): Promise<void>;
+    startFaceMatch(firstImage: TFrameType, secondImage: TFrameType): Promise<void>;
     tryStartFaceMatch(): Promise<void>;
-    startAll(file: TFileType, startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): void;
+    startAll(file: TFrameType, startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): void;
 }
 type TResultStatuses = 'success' | 'error' | null;
-export interface IUploadIdentificationDocumentResults<TFileType> {
-    uploadedDocument: TFileType | null;
+export interface IUploadIdentificationDocumentResults<TFrameType> {
+    uploadedDocument: TFrameType | null;
     typification: {
         status: TResultStatuses;
         results: ITypificationResult | null;
@@ -32,7 +32,7 @@ export interface IUploadIdentificationDocumentResults<TFileType> {
     };
     liveness: {
         status: TResultStatuses;
-        results: ILivenessResults<TFileType | null | undefined> | null;
+        results: ILivenessResults<TFrameType | null | undefined> | null;
         loading: boolean;
         error: SDKError | null;
     };
@@ -47,9 +47,9 @@ type ICustomLivenessOptions<TFrameType, TMediaType> = Omit<ISDKOptions<TFrameTyp
     track?: string;
     token?: string;
 };
-export interface IServiceOptions<TFrameType, TMediaType, TFileType> extends IBaseSDKOptions {
+export interface IServiceOptions<TFrameType, TMediaType> extends IBaseSDKOptions {
     livenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>;
-    onUpdate?: (results?: IUploadIdentificationDocumentResults<TFileType>) => void | Promise<void>;
+    onUpdate?: (results?: IUploadIdentificationDocumentResults<TFrameType>) => void | Promise<void>;
     onSuccess?: <TFrameType, ResultsType = ILivenessResults<TFrameType>>(results?: ResultsType) => void | Promise<void>;
     onError?: (error?: SDKError) => void | Promise<void>;
     onEnd?: TCallbackFunction;

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;
@@ -114,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));
@@ -154,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);
@@ -172,6 +174,7 @@ class UploadIdentificationDocumentService {
             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));
@@ -191,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.d.ts

@@ -1,5 +1,8 @@
+export interface IStartGettingFramesOptions {
+    facingMode?: 'user' | 'environment';
+}
 export interface IFrameControls<TFrameType, TMediaType> {
-    startGettingFrames?: () => TMediaType | Promise<TMediaType>;
+    startGettingFrames?: (cameraOptions?: IStartGettingFramesOptions) => TMediaType | Promise<TMediaType>;
     getNextFrame?: () => TFrameType | Promise<TFrameType>;
     stopGettingFrames?: () => void | Promise<void>;
     videoStream?: TMediaType;

package/client/liveness/utils/getNextFrame.js

@@ -41,14 +41,20 @@ async function getDefaultFrameControls() {
             videoStream = undefined;
         }
     }
-    async function startGettingFrames() {
+    async function startGettingFrames(cameraOptions) {
+        var _a;
         if (!videoStream || !videoElement || !canvasElement) {
-            videoStream = await navigator.mediaDevices.getUserMedia({ video: true });
+            videoStream = await navigator.mediaDevices.getUserMedia({
+                audio: false,
+                video: {
+                    facingMode: (_a = cameraOptions === null || cameraOptions === void 0 ? void 0 : cameraOptions.facingMode) !== null && _a !== void 0 ? _a : 'user',
+                },
+            });
             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.2.0",
+  "version": "5.4.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' | 'onCameraStart' | 'onCameraStop'> & {
+    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' | 'onCameraStart' | 'onCameraStop'> & {
+    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' | 'onCameraStart' | 'onCameraStop'> & {
+    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 {};