santoid-sdk 5.1.0 → 5.3.0

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

@@ -0,0 +1,126 @@
+"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();
+            }
+        }
+    }
+    getVideoStream() {
+        var _a;
+        return (_a = this.frameGetControls) === null || _a === void 0 ? void 0 : _a.videoStream;
+    }
+    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: () => 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 () => {
+                await service.startCamera();
+            },
+            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,13 @@
+import { type ITypificationResult } from '../../../../api/ApiTypificationService';
+import { ApiOcrService } from '../../../../api/ApiOcrService';
+import { type TCoreServiceOptions } from '../../utils/types';
+import { BaseCoreService } from '../../commons/BaseCoreService';
+export type TOcrServiceOptions<TMediaType> = TCoreServiceOptions<TMediaType, ITypificationResult> & {
+    template: string;
+};
+export declare class OcrService<TFrameType, TMediaType> extends BaseCoreService<TFrameType, TMediaType, ITypificationResult> {
+    service: ApiOcrService<TFrameType>;
+    constructor(options: TOcrServiceOptions<TMediaType>);
+    getVideoStream(): TMediaType | undefined;
+    startProcessing(file: TFrameType): Promise<void>;
+}

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

@@ -0,0 +1,56 @@
+"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 });
+    }
+    getVideoStream() {
+        var _a;
+        return (_a = this.frameGetControls) === null || _a === void 0 ? void 0 : _a.videoStream;
+    }
+    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: () => 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 () => {
+                await service.startCamera();
+            },
+            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,10 @@
+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>);
+    getVideoStream(): TMediaType;
+    startProcessing(file: TFrameType): Promise<void>;
+}

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

@@ -0,0 +1,56 @@
+"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 });
+    }
+    getVideoStream() {
+        var _a;
+        return (_a = this.frameGetControls) === null || _a === void 0 ? void 0 : _a.videoStream;
+    }
+    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: () => 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,41 @@
+"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 () => {
+                await service.startCamera();
+            },
+            stopCamera: async () => {
+                await service.stopCamera();
+            },
+            captureImage: async () => {
+                return await service.captureImage();
+            },
+            getVideoStream: () => {
+                return service.getVideoStream();
+            },
+            sendFile: async (file) => {
+                await service.startProcessing(file);
+            },
+        };
+    }
+    catch (err) {
+        console.error(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,26 @@
+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>;
+    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: unknown) => 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;
 }

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,28 +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>;
-    startDocumentUpload(file: TFileType): Promise<void>;
+    waitForResultsFaceMatch(requestId: string): Promise<IFaceMatchResult>;
+    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;
@@ -31,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;
     };
@@ -46,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;