santoid-sdk 5.2.0 → 5.4.0

package/client/core/commons/BaseCoreService.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCoreService = void 0;
+const error_1 = require("../../../utils/error");
+const getNextFrame_1 = require("../../liveness/utils/getNextFrame");
+class BaseCoreService {
+    constructor(options) {
+        this.results = { status: null, results: null, loading: false, error: null };
+        this.cameraIsActive = false;
+        this.cameraIsSetup = false;
+        this.options = options;
+    }
+    async initialize(file) {
+        var _a;
+        if (file) {
+            // Start processing immediately
+            this.startProcessing(file);
+        }
+        else {
+            // If necessary, open camera and take photo before start processing
+            const startTheCameraImmediately = (_a = this.options.startTheCameraImmediately) !== null && _a !== void 0 ? _a : this.options.startTheCameraImmediately === undefined;
+            if (startTheCameraImmediately) {
+                await this.startCamera();
+            }
+        }
+    }
+    async updateResults(updatedResults) {
+        var _a, _b;
+        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));
+    }
+    getVideoStream() {
+        var _a;
+        return (_a = this.frameGetControls) === null || _a === void 0 ? void 0 : _a.videoStream;
+    }
+    async setupCamera() {
+        this.frameGetControls = await (0, getNextFrame_1.getDefaultFrameControls)();
+        this.cameraIsSetup = true;
+    }
+    async startCamera(cameraOptions) {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            if (this.cameraIsActive) {
+                throw new error_1.SDKError({
+                    message: 'The camera has already been initialized',
+                    code: error_1.ECameraErrorCodes.ALREADY_STARTED,
+                    fatal: false,
+                });
+            }
+            if (this.results.loading) {
+                throw new error_1.SDKError({
+                    message: 'Typification processing has already started',
+                    code: error_1.EProcessingErrorCodes.ALREADY_STARTED,
+                    fatal: false,
+                });
+            }
+            if (!this.cameraIsSetup) {
+                await this.setupCamera();
+            }
+            this.frameGetControls.videoStream = await ((_b = (_a = this.frameGetControls).startGettingFrames) === null || _b === void 0 ? void 0 : _b.call(_a, cameraOptions));
+            await ((_d = (_c = this.options).onCameraStart) === null || _d === void 0 ? void 0 : _d.call(_c, { videoStream: this.getVideoStream() }));
+            this.cameraIsActive = true;
+        }
+        catch (err) {
+            const validatedError = err instanceof error_1.SDKError
+                ? err
+                : new error_1.SDKError({
+                    message: 'Camera initialization error',
+                    code: error_1.ECameraErrorCodes.INITIALIZATION_ERROR,
+                    fatal: false,
+                    details: err,
+                });
+            await ((_f = (_e = this.options).onError) === null || _f === void 0 ? void 0 : _f.call(_e, validatedError));
+        }
+    }
+    async stopCamera() {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            if (!this.cameraIsActive) {
+                throw new error_1.SDKError({
+                    message: 'Camera not initialized',
+                    code: error_1.ECameraErrorCodes.NOT_INITIALIZED,
+                    fatal: false,
+                });
+            }
+            await ((_b = (_a = this.frameGetControls).stopGettingFrames) === null || _b === void 0 ? void 0 : _b.call(_a));
+            await ((_d = (_c = this.options).onCameraStop) === null || _d === void 0 ? void 0 : _d.call(_c));
+            this.cameraIsActive = false;
+        }
+        catch (err) {
+            const validatedError = err instanceof error_1.SDKError
+                ? err
+                : new error_1.SDKError({
+                    message: 'Error during camera shutdown',
+                    code: error_1.ECameraErrorCodes.SHUTDOWN_ERROR,
+                    fatal: false,
+                    details: err,
+                });
+            await ((_f = (_e = this.options).onError) === null || _f === void 0 ? void 0 : _f.call(_e, validatedError));
+        }
+    }
+    async captureImage({ startProcessing = true } = {}) {
+        var _a, _b;
+        const bytes = await ((_b = (_a = this.frameGetControls).getNextFrame) === null || _b === void 0 ? void 0 : _b.call(_a));
+        if (bytes) {
+            if (startProcessing) {
+                await this.stopCamera();
+                await this.startProcessing(bytes);
+            }
+            return bytes;
+        }
+        else {
+            throw new error_1.SDKError({
+                message: 'Cannot capture image',
+                code: error_1.ECameraErrorCodes.CANNOT_CAPTURE_IMAGE,
+                fatal: false,
+            });
+        }
+    }
+    async waitForResults(requestId) {
+        let validationNotified = false;
+        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.service.get(requestId);
+                    if ((data === null || data === void 0 ? void 0 : data.status) === 'validation' && !validationNotified) {
+                        await ((_d = (_c = this.options).onValidationRequested) === null || _d === void 0 ? void 0 : _d.call(_c, {
+                            track: this.options.track,
+                            requestId: data.id,
+                        }));
+                        validationNotified = true;
+                        return;
+                    }
+                    if ((data === null || data === void 0 ? void 0 : data.status) === 'error') {
+                        throw new Error('Não foi possível processar os resultados do Upload de Documentos');
+                    }
+                    if ((data === null || data === void 0 ? void 0 : data.status) === 'processed' && data.fileURL) {
+                        const response = await fetch(data.fileURL);
+                        const typificationResults = await response.json();
+                        if (typificationResults) {
+                            clearInterval(interval);
+                            resolve(typificationResults);
+                        }
+                    }
+                }
+                catch (error) {
+                    clearInterval(interval);
+                    reject(error);
+                }
+            }, 5000);
+        });
+    }
+}
+exports.BaseCoreService = BaseCoreService;

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

@@ -0,0 +1,19 @@
+import { ApiFaceMatchService, type IFaceMatchResult } from '../../../../api/ApiFaceMatchService';
+import { type TCoreServiceOptions } from '../../utils/types';
+import { BaseCoreService } from '../../commons/BaseCoreService';
+export type TFaceMatchServiceOptions<TMediaType> = Omit<TCoreServiceOptions<TMediaType, IFaceMatchResult>, 'template' | 'onValidationRequested'>;
+export declare class FaceMatchService<TFrameType, TMediaType> extends BaseCoreService<TFrameType, TMediaType, IFaceMatchResult> {
+    service: ApiFaceMatchService<TFrameType>;
+    selectedFile1: TFrameType | undefined;
+    selectedFile2: TFrameType | undefined;
+    constructor(options: TFaceMatchServiceOptions<TMediaType>);
+    initialize(file1?: TFrameType, file2?: TFrameType): Promise<void>;
+    captureFirstImage({ startProcessing }?: {
+        startProcessing?: boolean | undefined;
+    }): Promise<NonNullable<Awaited<TFrameType>>>;
+    captureSecondImage({ startProcessing }?: {
+        startProcessing?: boolean | undefined;
+    }): Promise<NonNullable<Awaited<TFrameType>>>;
+    startProcessing(file1: TFrameType, file2?: TFrameType): Promise<void>;
+    waitForResultsFaceMatch(requestId: string): Promise<IFaceMatchResult>;
+}

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaceMatchService = void 0;
+const uuid_1 = require("uuid");
+const error_1 = require("../../../../utils/error");
+const utils_1 = require("../../../liveness/utils");
+const ApiFaceMatchService_1 = require("../../../../api/ApiFaceMatchService");
+const BaseCoreService_1 = require("../../commons/BaseCoreService");
+class FaceMatchService extends BaseCoreService_1.BaseCoreService {
+    constructor(options) {
+        super(options);
+        this.selectedFile1 = undefined;
+        this.selectedFile2 = undefined;
+        this.service = new ApiFaceMatchService_1.ApiFaceMatchService(options, { FormDataClass: FormData, tryDecodeJwt: utils_1.tryDecodeJwt });
+    }
+    async initialize(file1, file2) {
+        var _a;
+        if (file1) {
+            // Start processing immediately
+            this.startProcessing(file1, file2);
+        }
+        else {
+            // If necessary, open camera and take photo before start processing
+            const startTheCameraImmediately = (_a = this.options.startTheCameraImmediately) !== null && _a !== void 0 ? _a : this.options.startTheCameraImmediately === undefined;
+            if (startTheCameraImmediately) {
+                await this.startCamera();
+            }
+        }
+    }
+    async captureFirstImage({ startProcessing = true } = {}) {
+        // The superclass only works with one file
+        const bytes = await super.captureImage({ startProcessing: false });
+        this.selectedFile1 = bytes;
+        if (startProcessing) {
+            await this.stopCamera();
+            await this.startProcessing(this.selectedFile1);
+        }
+        return bytes;
+    }
+    async captureSecondImage({ startProcessing = true } = {}) {
+        if (!this.selectedFile1) {
+            throw new error_1.SDKError({
+                message: 'Select the first image before selecting the second',
+                code: error_1.EFaceMatchErrorCodes.FIRST_IMAGE_NOT_SELECTED,
+                fatal: false,
+            });
+        }
+        // The superclass only works with one file
+        const bytes = await super.captureImage({ startProcessing: false });
+        this.selectedFile2 = bytes;
+        if (startProcessing) {
+            await this.stopCamera();
+            await this.startProcessing(this.selectedFile1, this.selectedFile2);
+        }
+        return bytes;
+    }
+    async startProcessing(file1, file2) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        try {
+            if (this.cameraIsActive) {
+                throw new error_1.SDKError({
+                    message: 'Cannot start because the camera is running',
+                    code: error_1.ECameraErrorCodes.IS_RUNNING,
+                    fatal: false,
+                });
+            }
+            if ((_a = this.results) === null || _a === void 0 ? void 0 : _a.loading) {
+                throw new error_1.SDKError({
+                    message: 'Processing has already started',
+                    code: error_1.EProcessingErrorCodes.ALREADY_STARTED,
+                    fatal: false,
+                });
+            }
+            this.updateResults({ status: null, results: null, loading: true, error: null });
+            const { requestId } = await this.service.faceMatch(file1, file2, `sdk-ocr-${(0, uuid_1.v4)()}`);
+            const results = await this.waitForResultsFaceMatch(requestId);
+            this.updateResults({ status: 'success', results, loading: false, error: null });
+            (_c = (_b = this.options).onSuccess) === null || _c === void 0 ? void 0 : _c.call(_b, results);
+            (_e = (_d = this.options).onEnd) === null || _e === void 0 ? void 0 : _e.call(_d);
+        }
+        catch (err) {
+            const validatedError = err instanceof error_1.SDKError
+                ? err
+                : new error_1.SDKError({
+                    message: 'Error during document upload/analysis',
+                    code: error_1.EProcessingErrorCodes.PROCESSING_ERROR,
+                    fatal: false,
+                    details: err,
+                });
+            await ((_g = (_f = this.options).onError) === null || _g === void 0 ? void 0 : _g.call(_f, validatedError));
+            this.updateResults({ status: 'error', results: null, loading: false, error: validatedError });
+        }
+    }
+    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.service.get(requestId);
+                    if ((data === null || data === void 0 ? void 0 : data.status) === 'error' || (data === null || data === void 0 ? void 0 : data.status) === 'error_connector') {
+                        throw new Error('Não foi possível processar os resultados do FaceMatch');
+                    }
+                    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);
+        });
+    }
+}
+exports.FaceMatchService = FaceMatchService;

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

@@ -0,0 +1,15 @@
+import { type TFaceMatchServiceOptions } from './Service';
+export type TFrameType = File | Blob;
+export type TMediaType = MediaStream | undefined;
+export declare function faceMatch(options: TFaceMatchServiceOptions<TMediaType>, file1?: TFrameType, file2?: TFrameType): Promise<{
+    startCamera: (cameraOptions?: import("../../../liveness/utils/getNextFrame").IStartGettingFramesOptions | undefined) => Promise<void>;
+    stopCamera: () => Promise<void>;
+    captureFirstImage: (rest_0?: {
+        startProcessing?: boolean | undefined;
+    } | undefined) => Promise<NonNullable<TFrameType>>;
+    captureSecondImage: (rest_0?: {
+        startProcessing?: boolean | undefined;
+    } | undefined) => Promise<NonNullable<TFrameType>>;
+    getVideoStream: () => TMediaType;
+    sendFiles: (file1: TFrameType, file2?: TFrameType | undefined) => Promise<void>;
+}>;

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

@@ -0,0 +1,43 @@
+"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.FaceMatchService(options);
+        await service.initialize(file1, file2);
+        await ((_b = (_a = service.options).onStart) === null || _b === void 0 ? void 0 : _b.call(_a, { videoStream: service.getVideoStream() }));
+        // Methods are exported like this to prevent the value of "this" from changing
+        return {
+            startCamera: async (...rest) => {
+                await service.startCamera(...rest);
+            },
+            stopCamera: async () => {
+                await service.stopCamera();
+            },
+            captureFirstImage: async (...rest) => {
+                return await service.captureFirstImage(...rest);
+            },
+            captureSecondImage: async (...rest) => {
+                return await service.captureSecondImage(...rest);
+            },
+            getVideoStream: () => {
+                return service.getVideoStream();
+            },
+            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/client/core/methods/ocr/Service.d.ts

@@ -0,0 +1,11 @@
+import { ApiOcrService, type IOcrResult } from '../../../../api/ApiOcrService';
+import { type TCoreServiceOptions } from '../../utils/types';
+import { BaseCoreService } from '../../commons/BaseCoreService';
+export type TOcrServiceOptions<TMediaType> = TCoreServiceOptions<TMediaType, IOcrResult> & {
+    template: string;
+};
+export declare class OcrService<TFrameType, TMediaType> extends BaseCoreService<TFrameType, TMediaType, IOcrResult> {
+    service: ApiOcrService<TFrameType>;
+    constructor(options: TOcrServiceOptions<TMediaType>);
+    startProcessing(file: TFrameType): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcrService = void 0;
+const uuid_1 = require("uuid");
+const error_1 = require("../../../../utils/error");
+const utils_1 = require("../../../liveness/utils");
+const ApiOcrService_1 = require("../../../../api/ApiOcrService");
+const BaseCoreService_1 = require("../../commons/BaseCoreService");
+class OcrService extends BaseCoreService_1.BaseCoreService {
+    constructor(options) {
+        super(options);
+        this.service = new ApiOcrService_1.ApiOcrService(options, { FormDataClass: FormData, tryDecodeJwt: utils_1.tryDecodeJwt });
+    }
+    async startProcessing(file) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        try {
+            if (this.cameraIsActive) {
+                throw new error_1.SDKError({
+                    message: 'Cannot start because the camera is running',
+                    code: error_1.ECameraErrorCodes.IS_RUNNING,
+                    fatal: false,
+                });
+            }
+            if ((_a = this.results) === null || _a === void 0 ? void 0 : _a.loading) {
+                throw new error_1.SDKError({
+                    message: 'Processing has already started',
+                    code: error_1.EProcessingErrorCodes.ALREADY_STARTED,
+                    fatal: false,
+                });
+            }
+            this.updateResults({ status: null, results: null, loading: true, error: null });
+            const { requestId } = await this.service.extract(file, `sdk-ocr-${(0, uuid_1.v4)()}`);
+            const results = await this.waitForResults(requestId);
+            this.updateResults({ status: 'success', results, loading: false, error: null });
+            (_c = (_b = this.options).onSuccess) === null || _c === void 0 ? void 0 : _c.call(_b, results);
+            (_e = (_d = this.options).onEnd) === null || _e === void 0 ? void 0 : _e.call(_d);
+        }
+        catch (err) {
+            const validatedError = err instanceof error_1.SDKError
+                ? err
+                : new error_1.SDKError({
+                    message: 'Error during document upload/analysis',
+                    code: error_1.EProcessingErrorCodes.PROCESSING_ERROR,
+                    fatal: false,
+                    details: err,
+                });
+            await ((_g = (_f = this.options).onError) === null || _g === void 0 ? void 0 : _g.call(_f, validatedError));
+            this.updateResults({ status: 'error', results: null, loading: false, error: validatedError });
+        }
+    }
+}
+exports.OcrService = OcrService;

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

@@ -0,0 +1,10 @@
+import { type TOcrServiceOptions } from './Service';
+export type TFrameType = File | Blob;
+export type TMediaType = MediaStream | undefined;
+export declare function ocr(options: TOcrServiceOptions<TMediaType>, file?: TFrameType): Promise<{
+    startCamera: (cameraOptions?: import("../../../liveness/utils/getNextFrame").IStartGettingFramesOptions | undefined) => Promise<void>;
+    stopCamera: () => Promise<void>;
+    captureImage: () => Promise<NonNullable<TFrameType>>;
+    getVideoStream: () => TMediaType;
+    sendFile: (file: TFrameType) => Promise<void>;
+}>;

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

@@ -0,0 +1,40 @@
+"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.OcrService(options);
+        await service.initialize(file);
+        await ((_b = (_a = service.options).onStart) === null || _b === void 0 ? void 0 : _b.call(_a, { videoStream: service.getVideoStream() }));
+        // Methods are exported like this to prevent the value of "this" from changing
+        return {
+            startCamera: async (...rest) => {
+                await service.startCamera(...rest);
+            },
+            stopCamera: async () => {
+                await service.stopCamera();
+            },
+            captureImage: async () => {
+                return await service.captureImage();
+            },
+            getVideoStream: () => {
+                return service.getVideoStream();
+            },
+            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/client/core/methods/typification/Service.d.ts

@@ -0,0 +1,9 @@
+import { ApiTypificationService, type ITypificationResult } from '../../../../api/ApiTypificationService';
+import { type TCoreServiceOptions } from '../../utils/types';
+import { BaseCoreService } from '../../commons/BaseCoreService';
+export type TTypificationServiceOptions<TMediaType> = Omit<TCoreServiceOptions<TMediaType, ITypificationResult>, 'template'>;
+export declare class TypificationService<TFrameType, TMediaType> extends BaseCoreService<TFrameType, TMediaType, ITypificationResult> {
+    service: ApiTypificationService<TFrameType>;
+    constructor(options: TTypificationServiceOptions<TMediaType>);
+    startProcessing(file: TFrameType): Promise<void>;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypificationService = void 0;
+const uuid_1 = require("uuid");
+const error_1 = require("../../../../utils/error");
+const utils_1 = require("../../../liveness/utils");
+const ApiTypificationService_1 = require("../../../../api/ApiTypificationService");
+const BaseCoreService_1 = require("../../commons/BaseCoreService");
+class TypificationService extends BaseCoreService_1.BaseCoreService {
+    constructor(options) {
+        super(options);
+        this.service = new ApiTypificationService_1.ApiTypificationService(options, { FormDataClass: FormData, tryDecodeJwt: utils_1.tryDecodeJwt });
+    }
+    async startProcessing(file) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        try {
+            if (this.cameraIsActive) {
+                throw new error_1.SDKError({
+                    message: 'Cannot start because the camera is running',
+                    code: error_1.ECameraErrorCodes.IS_RUNNING,
+                    fatal: false,
+                });
+            }
+            if ((_a = this.results) === null || _a === void 0 ? void 0 : _a.loading) {
+                throw new error_1.SDKError({
+                    message: 'Processing has already started',
+                    code: error_1.EProcessingErrorCodes.ALREADY_STARTED,
+                    fatal: false,
+                });
+            }
+            this.updateResults({ status: null, results: null, loading: true, error: null });
+            const { requestId } = await this.service.predict(file, `sdk-typification-${(0, uuid_1.v4)()}`);
+            const results = await this.waitForResults(requestId);
+            this.updateResults({ status: 'success', results, loading: false, error: null });
+            (_c = (_b = this.options).onSuccess) === null || _c === void 0 ? void 0 : _c.call(_b, results);
+            (_e = (_d = this.options).onEnd) === null || _e === void 0 ? void 0 : _e.call(_d);
+        }
+        catch (err) {
+            const validatedError = err instanceof error_1.SDKError
+                ? err
+                : new error_1.SDKError({
+                    message: 'Error during document upload/analysis',
+                    code: error_1.EProcessingErrorCodes.PROCESSING_ERROR,
+                    fatal: false,
+                    details: err,
+                });
+            await ((_g = (_f = this.options).onError) === null || _g === void 0 ? void 0 : _g.call(_f, validatedError));
+            this.updateResults({ status: 'error', results: null, loading: false, error: validatedError });
+        }
+    }
+}
+exports.TypificationService = TypificationService;

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

@@ -0,0 +1,10 @@
+import { type TTypificationServiceOptions } from './Service';
+export type TFrameType = File | Blob;
+export type TMediaType = MediaStream | undefined;
+export declare function typification(options: TTypificationServiceOptions<TMediaType>, file?: TFrameType): Promise<{
+    startCamera: (cameraOptions?: import("../../../liveness/utils/getNextFrame").IStartGettingFramesOptions | undefined) => Promise<void>;
+    stopCamera: () => Promise<void>;
+    captureImage: () => Promise<NonNullable<TFrameType>>;
+    getVideoStream: () => TMediaType;
+    sendFile: (file: TFrameType) => Promise<void>;
+}>;

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

@@ -0,0 +1,40 @@
+"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.TypificationService(options);
+        await service.initialize(file);
+        await ((_b = (_a = service.options).onStart) === null || _b === void 0 ? void 0 : _b.call(_a, { videoStream: service.getVideoStream() }));
+        // Methods are exported like this to prevent the value of "this" from changing
+        return {
+            startCamera: async (...rest) => {
+                await service.startCamera(...rest);
+            },
+            stopCamera: async () => {
+                await service.stopCamera();
+            },
+            captureImage: async () => {
+                return await service.captureImage();
+            },
+            getVideoStream: () => {
+                return service.getVideoStream();
+            },
+            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/client/core/utils/types.d.ts

@@ -0,0 +1,30 @@
+import { type SDKError } from '../../../utils/error';
+import { type IBaseSDKOptions, type TCallbackFunction } from '../../../utils/types';
+export type TCoreServiceOptions<TMediaType, TResultsContentType> = IBaseSDKOptions & {
+    onStart?: (params: {
+        videoStream: TMediaType;
+    }) => void | Promise<void>;
+    onCameraStart?: (params: {
+        videoStream: TMediaType;
+    }) => void | Promise<void>;
+    onCameraStop?: () => void | Promise<void>;
+    onUpdate?: (results?: ICoreServiceResult<TResultsContentType>) => void | Promise<void>;
+    onValidationRequested?: (requestInformation: IRequestInformation) => void | Promise<void>;
+    onClearInterval?: (interval: ReturnType<typeof setInterval>) => void | Promise<void>;
+    onError?: (error?: SDKError) => void | Promise<void>;
+    onSuccess?: (results: TResultsContentType) => void | Promise<void>;
+    onEnd?: TCallbackFunction;
+    startTheCameraImmediately?: boolean;
+};
+interface IRequestInformation {
+    track: string;
+    requestId: string;
+}
+export type TResultStatuses = 'success' | 'error' | null;
+export interface ICoreServiceResult<TResultsContentType> {
+    status: TResultStatuses;
+    results: TResultsContentType | null;
+    loading: boolean;
+    error: SDKError | null;
+}
+export {};

package/client/core/utils/types.js

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

package/client/index.d.ts

@@ -1,8 +1,14 @@
 import { livenessDetection } from './liveness/methods/livenessDetection';
 import { uploadIdentificationDocument } from './liveness/methods/uploadIdentificationDocument';
 import { insertUploadIdentificationDocument } from './embedded/methods/insertUploadIdentificationDocument';
+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 insertUploadIdentificationDocument: typeof insertUploadIdentificationDocument;
+    static readonly typification: typeof typification;
+    static readonly ocr: typeof ocr;
+    static readonly faceMatch: typeof faceMatch;
 }