santoid-sdk 2.0.2 → 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## Versão 3.0.0
+
+### Mudanças
+
+- Os nomes de métodos de callback disponíveis nas opções do SDK foram alterados do padrão **nome** + **Callback** para **on** + **Nome**
+- O mecanismo de envio de frames foi melhorado para evitar o envio de frames fora de ordem
+- Agora as funções **livenessDetection** e **uploadIdentificationDocument** são síncronas e todo o monitoramento de status dos processamentos deve ser feito por meio dos métodos de callback
+- Nova função **onStart**, executada quando a verificação de prova de vida é iniciada
+- Novas funções **resumeGettingFrames** e **pauseGettingFrames** para controlar o envio de frames

package/README.md

@@ -35,7 +35,7 @@ async function startSDK () {
 startSDK()
 ```
 
-Você também pode passar as credenciais (em formato de objeto ou transformadas em base64) como parâmetro da função de inicialização.
+Você também pode passar as credenciais em formato de objeto ou transformadas em base64 por meio da propriedade **credentials** do objeto de opções de inicialização.
 
 ```ts
 import { initialize } from 'santoid-sdk/node/auth'
@@ -47,7 +47,7 @@ async function startSDK () {
   // ...
 }
 
-// Certifique-se de que o usuário está autenticado
+// Certifique-se de que o usuário está autenticado antes
 startSDK()
 ```
 
@@ -57,70 +57,105 @@ startSDK()
 Atualmente, o SDK conta com a funcionalidade de **Prova de Vida**, que possibilita a verificação do usuário atual, avaliando se uma pessoa real está realizando as atividades online por meio de uma rápida análise facial.
 
 #### Utilização em JavaScript
-Para utilizar a funcionalidade de Prova de Vida, é necessário importar a função para iniciar a verificação e passar alguns parâmetros:
+Para utilizar a funcionalidade de Prova de Vida, é necessário importar a função para iniciar a verificação e passar alguns valores dentro do objeto de opções, como no exemplo abaixo:
 
 ```ts
 import { livenessDetection } from 'santoid-sdk/liveness'
 
-async function startLivenessDetection () {
-  await livenessDetection({
-    token: 'string', // Token obtido por meio da autenticação
-    track: 'string', // Processo
-    customId: 'string', // (Opcional) ID customizado para auditoria
+const livenessDetectionResponse = livenessDetection({
+  token: 'string',
+  track: 'string',
+  customId: 'string',
 
-    // (Opcional no JavaScript, obrigatório no Node.js)
-    // É necessário fornecer uma função que retorne os frames a serem verificados no formato Blob do JavaScript
-    // A função será executada várias vezes, e o SDK espera que ela retorne um Blob a cada execução
-    getNextFrame: () => {
-      // ...
-    },
+  getNextFrame: () => {
+    // ...
+  },
 
-    // (Opcional) Função executada cada vez que uma nova posição é solicitada na verificação facial
-    nextStepCallback: (step) => {}, 
+  // ...
+})
 
-    // (Opcional) Funções individuais para cada posição solicitada
-    frontCallback: () => {},
-    rightCallback: () => {},
-    leftCallback: () => {},
-    upCallback: () => {},
-    bottomCallback: () => {},
+const { getVideoStream, stopLivenessDetection, resumeGettingFrames, pauseGettingFrames } = livenessDetectionResponse
+```
 
-    // (Opcional) Função executada em caso de erro
-    errorCallback: ({ errorCode }) => {},
+As propriedades disponíveis para utilização no objeto de opções estão listadas na tabela abaixo.
+
+#### Opções para a função livenessDetection (JavaScript)
+
+| Nome da propriedade | Função | É obrigatório? |
+| ------------------- | ------ | -------------- |
+| token               | Token de acesso obtido por meio da autenticação. | Sim |
+| track               | Identificador do processo que será utilizado. | Sim |
+| customId            | Identificador customizado para auditoria. | Não |
+| startGettingFrames  | Função executada quando a obtenção de frames for iniciada. <br>Se retornar um valor do tipo MediaStream, ele será salvo e fornecido <br>por meio da função **getVideoStream**. | Não |
+| getNextFrame        | Função que deve retornar os frames no formato **File ou Blob**. <br>Será executada várias vezes e deve sempre devolver o próximo frame. | Não |
+| stopGettingFrames   | Função executada quando a obtenção de frames for finalizada. | Não | 
+| onStart             | Função executada quando a verificação for iniciada. <br>Disponibiliza pelos parâmetros um objeto contendo a stream da <br>transmissão (**videoStream**), caso disponível. | Não |
+| onNextStep          | Função executada sempre que a validação muda para a próxima etapa. <br>Disponibiliza pelos parâmetros a etapa atual ('front', 'left', 'right', 'up' ou 'bottom'). | Não |
+| onFrontStep         | Função executada quando a etapa 'front' é iniciada. | Não |
+| onLeftStep          | Função executada quando a etapa 'left' é iniciada. | Não |
+| onRightStep         | Função executada quando a etapa 'right' é iniciada. | Não |
+| onUpStep            | Função executada quando a etapa 'up' é iniciada. | Não |
+| onBottomStep        | Função executada quando a etapa 'bottom' é iniciada. | Não |
+| onError             | Função executada quando ocorre um erro. <br>Disponibiliza pelos parâmetros a instância do erro, a qual <br>contém um identificador (propriedade **code**). | Não |
+| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br>Disponibiliza pelos parâmetros um objeto com os resultados, compostos <br>pelo ID da solicitação (**livenessId**) <br>e pelos frames de sucesso (**successFrames**). | Não |
+| onEnd               | Função executada quando a verificação é finalizada, seja com erro ou com sucesso. | Não |
+
+Caso a função seja executada em um navegador (ou ambiente semelhante que utilize JavaScript, como o WebView, por exemplo), não é obrigatório fornecer uma função que retorne os frames para verificação (getNextFrame), pois o próprio SDK iniciará a câmera e realizará todo o processo caso a função não seja fornecida.
+
+#### Retorno da função livenessDetection (JavaScript)
+A função livenessDetection retorna alguns métodos que possibilitam um melhor controle da verificação.
+
+| Nome da propriedade | Função |
+| ------------------- | ------ |
+| getVideoStream | Retorna a stream dos frames (MediaStream), caso ela esteja disponível. |
+| stopLivenessDetection | Para a verificação de prova de vida imediatamente e a finaliza completamente. |
+| pauseGettingFrames | Para a verificação temporariamente, a qual pode ser retomada posteriormente. |
+| resumeGettingFrames | Retoma a verificação, caso ela tenha sido pausada com a função pauseGettingFrames. |
 
-    // (Opcional) Função executada em caso de sucesso
-    // O ID da solicitação e os frames com sucesso podem ser recebidos pelos parâmetros, como no exemplo abaixo
-    successCallback: ({ livenessId, successFrames }) => {},
+```ts
+import { livenessDetection } from 'santoid-sdk/liveness'
 
-    // (Opcional) Função executada quando a validação é finalizada
-    endCallback: () => {},
-  })
-}
-```
+const livenessDetectionResponse = livenessDetection({
+  token: 'string',
+  track: 'string',
 
-Caso a função seja executada em um navegador (ou ambiente semelhante que utilize JavaScript, como o WebView, por exemplo), não é obrigatório fornecer uma função que retorne os frames para verificação. O próprio SDK iniciará a câmera e realizará todo o processo.
+  onStart ({ videoStream }) {
+    const video = document.querySelector('video')
+    video.srcObject = videoStream    
+  },
 
-Caso opte por utilizar essa verificação padrão do SDK (sem fornecer a função getNextFrame), é possível receber a propriedade **videoStream** como retorno da função para mostrar os frames que estão sendo obtidos em um player de vídeo.
+  onNextStep () {
+    pauseGettingFrames()
 
-A função também retorna um método chamado **stopLivenessDetection** que pode ser utilizado para interromper a verificação de forma imediata.
+    // Simulando intervalo de sucesso
+    setTimeout(() => {
+      resumeGettingFrames()
+    }, 1000)
+  },
 
-```ts
-import { livenessDetection } from 'santoid-sdk/liveness'
+  // ...
+})
 
-async function startLivenessDetection () {
-  const { videoStream, stopLivenessDetection } = await livenessDetection({
-    // ...
-  })
+// Funções retornadas
+const { getVideoStream, stopLivenessDetection, pauseGettingFrames, resumeGettingFrames } = livenessDetectionResponse
 
-  const video = document.querySelector('video')
-  video.srcObject = videoStream
-}
 ```
 #### Utilização em Node.js
-Caso deseje executar a função da prova de vida no servidor (Node.js), é obrigatório informar ao SDK a função de obtenção de frames, a qual deve retornar um Buffer ou semelhante (bytes da imagem do frame).
+Caso deseje executar a função da prova de vida no servidor (Node.js), **é obrigatório informar ao SDK a função de obtenção de frames** (getNextFrame), a qual deve retornar um Buffer ou semelhante (string, ArrayBuffer, Buffer ou Buffer[]) contendo os dados da imagem do frame.
 
 Fique atento ao caminho de importação da função, que muda para o caso de execução no servidor (Node.js):
 
+#### Opções para a função livenessDetection (Node.js)
+Para Node.js, as opções são quase as mesmas que as utilizadas em JavaScript, mudando apenas a obrigatoriedade de alguns valores. Abaixo estão listadas as propriedades que mudaram. As outras permanecem iguais às apresentadas anteriormente.
+
+| Nome da propriedade | Função | É obrigatório? |
+| ------------------- | ------ | -------------- |
+| startGettingFrames  | Função executada quando a obtenção de frames for iniciada. <br>Não precisa retornar nenhum valor. | Não |
+| getNextFrame        | Função que deve retornar os frames no formato **Buffer ou semelhante (string, ArrayBuffer, Buffer ou Buffer[])**. <br>Será executada várias vezes e deve sempre devolver o próximo frame. | Sim |
+
+#### Retorno da função livenessDetection (Node.js)
+Os itens retornados pela função livenessDetection para Node.js são semelhantes àos retornados pela função para JavaScript, com exceção da função **getVideoStream**, que não é retornada.
+
 ```ts
 import { livenessDetection } from 'santoid-sdk/node/liveness'
 
@@ -128,13 +163,17 @@ function getNextFrame (): string | ArrayBuffer | Buffer | Buffer[] {
   // ...
 }
 
-async function startLivenessDetection () {
-  await livenessDetection({
-    getNextFrame,
+const livenessDetectionResponse = livenessDetection({
+  token: 'string',
+  track: 'string',
+  
+  getNextFrame,
 
-    // ...
-  })
-}
+  // ...
+})
+
+// Funções retornadas
+const { stopLivenessDetection, pauseGettingFrames, resumeGettingFrames } = livenessDetectionResponse
 ```
 
 #### Utilização via CDN
@@ -144,6 +183,8 @@ Ao importar a biblioteca via tag script, a função **livenessDetection** ficar
 
 Substitua o **VERSION** pela versão desejada.
 
+Nesse modo de utilização, as opções disponíveis para configuração são as mesmas da versão JavaScript.
+
 ```html
 <body>
   <button onclick="startLiveness()">Iniciar</button>
@@ -151,10 +192,10 @@ Substitua o **VERSION** pela versão desejada.
   <script src="https://cdn.jsdelivr.net/npm/santoid-sdk@VERSION/browser/liveness/index.js"></script>
 
   <script>
-    async function startLiveness () {
-      await SantoiDSDK.livenessDetection({
-        track: 'test-track',
-        token: '...', // Token recebido via autenticação no back-end
+    function startLiveness () {
+      SantoiDSDK.livenessDetection({
+        track: 'string',
+        token: 'string',
 
         // ...
       })
@@ -163,103 +204,217 @@ Substitua o **VERSION** pela versão desejada.
 </body>
 ```
 
-### Fluxo Completo
-Com a funcionalidade do teste do fluxo completo do Santo iD, é possível iniciar a análise de prova de vida juntamente com a análise de um documento enviado ao mesmo tempo.
+### Teste do Fluxo Completo
+Com a funcionalidade do teste do fluxo completo do Santo iD, é possível iniciar a análise de prova de vida juntamente com a análise de um documento de identificação enviado, realizando também a comparação da face encontrada na prova de vida com a do documento ao final do processo.
 
 Ao chamar a função **uploadIdentificationDocument**, ela retorna um determinado conjunto de métodos, os quais possibilitam as análises.
 
 Com o método retornado **startAll** é possível iniciar todas as análises simultaneamente, porém também é possível iniciar uma de cada vez com os métodos **startDocumentUpload**, **startLivenessDetection** e **startFaceComparison**.
 
-Entretanto, o método **startFaceComparison** para a comparação entre as faces detectadas será chamado automaticamente quando os outros dois métodos forem chamados, sendo mais útil apenas para reiniciar a comparação em caso de erro.
+Entretanto, o método **startFaceComparison** para a comparação entre as faces detectadas será chamado automaticamente quando as outras análises forem concluídas, sendo mais útil apenas para reiniciar a comparação em caso de erro. Caso o método seja acionado quando as faces ainda não estiverem disponíveis para análise, a função **onError** será chamada com uma instância de erro como parâmetro, caso tenha sido fornecida.
 
 #### Utilização em JavaScript
 
+As propriedades disponíveis para utilização no objeto de opções estão listadas na tabela abaixo.
+
+#### Opções para a função uploadIdentificationDocument (JavaScript)
+
+| Nome da propriedade | Função | É obrigatório? |
+| ------------------- | ------ | -------------- |
+| token               | Token de acesso obtido por meio da autenticação. | Sim |
+| track               | Identificador do processo que será utilizado. | Sim |
+| livenessDetectionOptions | Opções para a verificação de prova de vida. | Não |
+| onUpdate            | Função executada toda vez que ocorre uma atualização no status geral <br>(quando alguma operação é iniciada ou concluída, quando ocorre erro, etc.). <br>Disponibiliza pelos parâmetros um objeto contendo as informações sobre a <br>situação de cada tipo de processamento realizado (envio de documento, prova de vida, etc.). | Não |
+| onError             | Função executada quando ocorre erro em alguma das operações. | Não |
+| onSuccess           | Função executada quando as verificações são finalizadas com sucesso. | Não |
+| onEnd               | Função executada quando a verificação é finalizada, seja com erro ou com sucesso. | Não |
+
 ```ts
 import { uploadIdentificationDocument } from 'santoid-sdk/liveness'
 
-const { startAll, startDocumentUpload, startLivenessDetection } = uploadIdentificationDocument({
-  token: '...',
-  track: '...',
-  domain: '...',
+const uploadIdentificationDocumentResponse = uploadIdentificationDocument({
+  token: 'string',
+  track: 'string',
 
-  resultChangeCallback (results) => {
+  onUpdate (results) => {
     // ...
   },
 
-  errorCallback (error) {
+  onError (error) {
     // ...
   },
 
-  successCallback (results) {
+  onSuccess (results) {
     // ...
   },
 
-  endCallback () {
+  onEnd () {
     // ...
   },
-})
 
-// Iniciar análises ao mesmo tempo
-startAll(file, {
-  // Opções para o liveness detection
-  // São os mesmos da função livenessDetection, porém não é necessário fornecer o token, a track e o domain novamente aqui
+  livenessDetectionOptions: {
+    getNextFrame () {
+      // ...
+    },
 
-  nextStepCallback (step) {
-    // ...
-  },
+    onSuccess () {
+      // ...
+    },
 
-  errorCallback (error) {
     // ...
   },
 
-  successCallback (results) {
-    // ...
-  },
+  // ...
+})
 
-  endCallback () {
-    // ...
-  },
+const {
+  startAll,
+  startDocumentUpload,
+  startLivenessDetection,
+  startFaceComparison,
+  getResults
+} = uploadIdentificationDocumentResponse
+```
 
-  // Opcional no ambiente client - Método para fornecer os frames para análise
-  getNextFrame () {
-    return file
-  },
-})
+#### Retorno da função uploadIdentificationDocument (JavaScript)
+A função uploadIdentificationDocument retorna alguns métodos que podem ser utilizados para dar controlar as análises.
+
+| Nome da propriedade | Função |
+| ------------------- | ------ |
+| startAll | Inicia todas as análises simultaneamente e espera dois parâmetros: o arquivo do documento (no formato **Blob** ou **File**) e, <br>opcionalmente, as configurações para a prova de vida (caso deseje sobrescrevê-las). |
+| startDocumentUpload | Inicia a etapa de upload/análise do documento que será enviado e espera receber um parâmetro com o arquivo. (no formato **Blob** ou **File**). |
+| startLivenessDetection | Inicia a verificação de prova de vida e aceita as mesmas opções que a função livenessDetection, caso deseje sobrescrevê-las. |
+| startFaceComparison | Inicia a comparação da face do documento com a face detectada na prova de vida. <br>Ela será iniciada automaticamente quando as outras análises forem concluídas, <br>porém você pode usar essa função para fazer uma nova tentativa em caso de falha. |
+| getResults | Retorna os status atuais de cada análise, no formato apresentado abaixo. |
+
+#### Formato dos resultados da função uploadIdentificationDocument
+```typescript
+interface IUploadIdentificationDocumentResults {
+  uploadedDocument: Blob | File | null
+  typification: {
+    status: TResultStatuses
+    results: ITypificationResult | null
+    loading: boolean
+    error: any
+  }
+  liveness: {
+    status: TResultStatuses
+    results: ILivenessResults<Blob | File | null | undefined> | null
+    loading: boolean
+    error: any
+  }
+  faceMatch: {
+    status: TResultStatuses
+    results: IFaceMatchResult | null
+    loading: boolean
+    error: any
+  }
+}
+```
 
-// Iniciar análises separadamente
-startDocumentUpload(file)
-startLivenessDetection({
-  // Opções para o liveness detection
+Em que:
 
-  nextStepCallback (step) {
-    // ...
-  },
+```typescript
+type TResultStatuses = 'success' | 'error' | null
 
-  // ...
-})
+interface ITypificationResult {
+  n_documents: number
+
+  predictOCR: Array<{
+    typification: {
+      document_type: string
+      ocr_success: boolean
+      typification_score: number
+    }
+
+    ocr_error?: boolean | null
+
+    ocr_message?: {
+      template: string
+      labels: any
+    } | null
+
+    ocr_extraction: {
+      template: string
+
+      labels: Array<{
+        x: number
+        y: number
+        w: number
+        h: number
+        bottomRight: number[]
+        topLeft: number[]
+
+        dataField?: string
+        dataFieldValue?: boolean
+
+        ocr?: string | null
+        ocr_score?: number
+        cropBase64?: string | null
+
+        serpro_query?: {
+          serpro_data: any
+          search_logs: {
+            document: string
+            type: string
+            search_time: string
+            status_code: number
+            message: string
+          }
+        }
+
+        validation?: Record<string, number | boolean>
+      }> | null
+    } | boolean
+  }>
+}
+
+export type TPositions = 'front' | 'right' | 'left' | 'up' | 'bottom'
+
+interface ILivenessResults {
+  livenessId: string
+  successFrames: Record<TPositions, Blob>
+}
+
+interface IFaceMatchResult {
+  comparison_score: number
+  similarity_score: number
+  match: boolean
+}
 ```
 
 #### Utilização em Node.js
-De forma semelhante à funcionalidade da Prova de Vida, para o Node.js o caminho da importação muda e a função getNextFrame passa a ser obrigatória e deve ser fornecida às opções para o livenessDetection.
+De forma semelhante à funcionalidade da Prova de Vida, para o Node.js o caminho da importação muda
+e a função **getNextFrame** passa a ser obrigatória e deve ser fornecida às opções para o livenessDetection.
+
+Outro detalhe é que no Node.js todos os tipos envolvendo **File** ou **Blob** passam a utilizar **Buffers**
+ou outros tipos equivalentes (string, ArrayBuffer, Buffer ou Buffer[]).
+
+Todos as outras opções e retornos se mantém os mesmos da versão para JavaScript.
 
 ```ts
 import { uploadIdentificationDocument } from 'santoid-sdk/node/liveness'
 
-const { startAll, startDocumentUpload, startLivenessDetection } = uploadIdentificationDocument({
-  // ...
-})
+const uploadIdentificationDocumentResponse = uploadIdentificationDocument({
+  token: 'string',
+  track: 'string',
 
-startAll(file, {
-  // ...
+  livenessDetectionOptions: {
+    getNextFrame () {
+      // ...
+    },
 
-  getNextFrame () {
-    return someBuffer
+    // ...
   },
+
+  // ...
 })
 ```
 
+
 #### Utilização via CDN
-De forma semelhante à funcionalidade da Prova de Vida, a funcionalidade do teste do fluxo completo também é disponibilizada globalmente por meio da classe SantoiDSDK.
+De forma semelhante à funcionalidade da Prova de Vida, a funcionalidade do teste do fluxo
+completo também é disponibilizada globalmente por meio da classe SantoiDSDK.
 
 Substitua o **VERSION** pela versão desejada.
 
@@ -278,6 +433,3 @@ Substitua o **VERSION** pela versão desejada.
   </script>
 </body>
 ```
-
-## Para desenvolvedores
-Caso seja um desenvolvedor da SantoDigital que deseje realizar alterações no SDK, confira o arquivo CONTRIBUTING.md presente na versão do projeto que está no repositório.

package/api/AbstractService.d.ts

@@ -0,0 +1,21 @@
+import { type IBaseSDKOptions } from '../utils/types';
+interface IBaseFormData {
+    append: (key: string, value: any, options?: string | undefined) => void;
+}
+type TFormDataClass = new () => IBaseFormData;
+export interface IAbstractServiceOptions {
+    FormDataClass: TFormDataClass;
+    tryDecodeJwt: <TDecodeReturnType = any>(token: string) => TDecodeReturnType | null;
+}
+export declare class AbstractService {
+    options: IBaseSDKOptions;
+    serviceOptions: IAbstractServiceOptions;
+    baseUrl: string;
+    constructor(options: IBaseSDKOptions, serviceOptions: IAbstractServiceOptions);
+    request({ contentType, authToken, baseUrl, }?: {
+        contentType?: string | undefined;
+        authToken?: string | undefined;
+        baseUrl?: string | undefined;
+    }): import("axios").AxiosInstance;
+}
+export {};

package/api/AbstractService.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const constants_1 = require("../utils/constants");
+class AbstractService {
+    constructor(options, serviceOptions) {
+        this.options = options;
+        this.serviceOptions = serviceOptions;
+    }
+    request(_a) {
+        var _b, _c, _d;
+        var { contentType = 'application/json', authToken = this.options.token, baseUrl = (_b = this.options.customApiUrl) !== null && _b !== void 0 ? _b : constants_1.API_GATEWAY_URL, } = _a === void 0 ? {} : _a;
+        const axiosConfig = {
+            baseURL: baseUrl,
+            headers: {
+                'Content-Type': contentType,
+                Authorization: `Bearer ${authToken}`,
+            },
+        };
+        const decodedToken = this.serviceOptions.tryDecodeJwt(this.options.token);
+        const domain = (_c = this.options.domain) !== null && _c !== void 0 ? _c : (_d = decodedToken === null || decodedToken === void 0 ? void 0 : decodedToken.claims) === null || _d === void 0 ? void 0 : _d.domain;
+        if (axiosConfig.headers && domain) {
+            axiosConfig.headers.Domain = domain;
+        }
+        return axios_1.default.create(axiosConfig);
+    }
+}
+exports.AbstractService = AbstractService;

package/api/FaceMatchService.d.ts

@@ -0,0 +1,9 @@
+import { AbstractService } from './AbstractService';
+export declare class FaceMatchService<TFileType> extends AbstractService {
+    faceMatch(firstImage: TFileType, secondImage: TFileType): Promise<IFaceMatchResult>;
+}
+export interface IFaceMatchResult {
+    comparison_score: number;
+    similarity_score: number;
+    match: boolean;
+}

package/api/FaceMatchService.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaceMatchService = void 0;
+const AbstractService_1 = require("./AbstractService");
+class FaceMatchService extends AbstractService_1.AbstractService {
+    async faceMatch(firstImage, secondImage) {
+        const formData = new this.serviceOptions.FormDataClass();
+        formData.append('track', this.options.track);
+        formData.append('firstImage', firstImage, 'firstImage.jpg');
+        formData.append('secondImage', secondImage, 'secondImage.jpg');
+        const response = await this.request({ contentType: 'multipart/form-data' }).post('/api/v1/facematch/pair', formData, { params: { sensitive_data_compliance: true } });
+        return response.data;
+    }
+}
+exports.FaceMatchService = FaceMatchService;

package/api/TypificationService.d.ts

@@ -0,0 +1,46 @@
+import { AbstractService } from './AbstractService';
+export declare class TypificationService<TFileType> extends AbstractService {
+    predict(imageFile: TFileType): Promise<ITypificationResult>;
+}
+export interface ITypificationResult {
+    n_documents: number;
+    predictOCR: Array<{
+        typification: {
+            document_type: string;
+            ocr_success: boolean;
+            typification_score: number;
+        };
+        ocr_error?: boolean | null;
+        ocr_message?: {
+            template: string;
+            labels: any;
+        } | null;
+        ocr_extraction: {
+            template: string;
+            labels: Array<{
+                x: number;
+                y: number;
+                w: number;
+                h: number;
+                bottomRight: number[];
+                topLeft: number[];
+                dataField?: string;
+                dataFieldValue?: boolean;
+                ocr?: string | null;
+                ocr_score?: number;
+                cropBase64?: string | null;
+                serpro_query?: {
+                    serpro_data: any;
+                    search_logs: {
+                        document: string;
+                        type: string;
+                        search_time: string;
+                        status_code: number;
+                        message: string;
+                    };
+                };
+                validation?: Record<string, number | boolean>;
+            }> | null;
+        } | boolean;
+    }>;
+}

package/api/TypificationService.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypificationService = void 0;
+const AbstractService_1 = require("./AbstractService");
+class TypificationService extends AbstractService_1.AbstractService {
+    async predict(imageFile) {
+        const formData = new this.serviceOptions.FormDataClass();
+        formData.append('track', this.options.track);
+        formData.append('imageFile', imageFile, 'imageFile.jpg');
+        const response = await this.request({ contentType: 'multipart/form-data' })
+            .post('/api/v3/typification/predict', formData);
+        return response.data;
+    }
+}
+exports.TypificationService = TypificationService;