santoid-sdk 5.3.0 → 7.0.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## Versão 5.5.0
+
+### Mudanças
+- Adicionada a função **livenessSession**, a prova de vida v2, sobre o **AWS Rekognition Face Liveness**. Ela cobre o ciclo de sessão (`createSession` e `getResults`), incluindo a espera pelo resultado enquanto o Rekognition ainda avalia. A captura em si — câmera, oval e desafio — é feita pelo `<FaceLivenessDetector>` da AWS, um componente React, e por isso não faz parte deste pacote.
+- A função **livenessDetection** foi marcada como **deprecada**. Ela é a prova de vida v1, baseada no detector in-house (WebSocket com o desafio de cinco posições). Continua funcionando e será mantida até a migração dos clientes, mas não recebe mais evolução — código novo deve usar **livenessSession**.
+- A URL padrão do WebSocket da v1 deixou de apontar para o endereço gerado do Cloud Run e passou a usar o domínio próprio `liveness.santoid.com.br`.
+
+## Versão 5.4.0
+- Foram adicionadas as funções de callback **onCameraStart** e **onCameraStop** para as funcionalidades de **Tipificação**, **OCR** e **Face Match**.
+- Agora as funções de iniciar câmera para **Tipificação**, **OCR** e **Face Match** possuem a opção **facingMode**, que permitem que o usuário especifique a direção desejada da câmera 
+
 ## Versão 5.3.0
 - Foram adicionadas as versões para consumo da **Tipificação**, do **OCR** e do **Face Match**.
 

package/README.md

@@ -54,11 +54,11 @@ startSDK()
 ## Envio de arquivos
 Um ponto importante são os tipos dos arquivos que são suportados pelo SDK.
 
-Para a execução em ambientes que utilizam JavaScript padrão, como os navegadores ou WebView, os tipos de arquivos suportados são **File** ou **Blob**.
+Para execução em navegadores e ambientes semelhantes, os tipos de arquivos suportados são **File** ou **Blob**.
 
 Para ambientes Node.js, os tipos dos arquivos devem ser **string, ArrayBuffer, Buffer ou Buffer[]**.
 
-## Utilização da biblioteca via CDN / Tags \<script\>
+## Utilização da biblioteca via CDN
 Caso deseje utilizar a biblioteca via CDN, importando-a diretamente em uma tag **script**, basta utilizar o caminho especificado no exemplo abaixo, substituindo o **VERSION** pela versão desejada.
 
 Ao importar a biblioteca via tag script, todas as funções do SDK ficarão disponíveis por meio da classe **SantoiDSDK**.
@@ -145,6 +145,7 @@ const typificationResponse = await typification({
 })
 
 typificationResponse.startCamera()
+typificationResponse.captureImage()
 
 // Ou
 
@@ -160,15 +161,29 @@ typificationResponse.sendFile(fileVariable)
 | customId            | Identificador customizado para auditoria. | Não |
 | startTheCameraImmediately | Booleano que determina se a câmera será acionada assim que a função for executada ou se será acionada manualmente depois. Por padrão, a câmera será acionada automaticamente. | Não |
 | onStart             | Função executada quando a verificação for iniciada. <br><br>Disponibiliza pelos parâmetros um objeto contendo a stream da transmissão (**videoStream**), caso disponível. | Não |
+| onCameraStart       | Função executada quando a câmera for iniciada. <br><br>Disponibiliza pelos parâmetros um objeto contendo a stream da transmissão (**videoStream**), caso disponível. | Não |
+| onCameraStop        | Função executada quando a câmera for interrompida. | Não |
 | onUpdate            | Função executada toda vez que ocorre uma atualização no status geral (quando alguma operação é iniciada ou concluída, quando ocorre erro, etc.). <br><br>Disponibiliza pelos parâmetros um objeto contendo as informações sobre a situação do processamento (qual o status atual, se está carregando, se existe erro, etc.) | Não |
 | onValidationRequested | Função executada quando o status do processamento é "validation". Retorna informações da requisição para que o usuário consiga fazer a validação manual da requisição | Não |
 | onError             | Função executada quando ocorre um erro. <br><br>Disponibiliza pelos parâmetros a instância do erro, a qual contém um identificador (propriedade **code**). | Não |
-| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br><br>Disponibiliza pelos parâmetros um objeto com os resultados, compostos pelo ID da solicitação (**livenessId**) e pelos frames de sucesso (**successFrames**). | Não |
+| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br><br>Disponibiliza pelos parâmetros um objeto com os resultados. | Não |
 | onEnd               | Função executada quando a verificação é finalizada, seja com erro ou com sucesso. | Não |
 
+#### Retorno da função typification (JavaScript)
+| Nome da propriedade | Função |
+| ------------------- | ------ |
+| startCamera         | Função para iniciar a câmera manualmente. <br><br>É possível informar nos parâmetros a direção de câmera desejada (**facingMode**), seguindo um modelo semelhante ao das funções de controle de câmera do próprio JavaScript (No mobile, por exemplo, facingMode == 'user' para usar a câmera da frente e facingMode == 'environment' para usar a câmera de trás). <br><br>Por padrão o facingMode é 'user'. |
+| stopCamera          | Função para desligar a câmera manualmente. |
+| captureImage        | Função para capturar a imagem que será utilizada para consumo com a câmera. |
+| getVideoStream      | Função para obter a stream de vídeo da câmera, se ela estiver disponível. |
+| sendFile            | Função para enviar arquivos manualmente, iniciando também o processamento. |
+
 #### Utilização em Node.js
 A utilização da função de Tipificação em Node.js é idêntica à utilização em JavaScript normal para browsers e ambientes semelhantes, com a exceção das funções e propriedades relacionadas à câmera, que não estão disponíveis nesta versão.
 
+#### Formato dos resultados
+Os resultados podem ser obtidos por meio da função de callback **onSuccess** por meio dos parâmetros. Sua estrutura é baseada na interface **ITypificationResult**, a qual pode ser consultada mais abaixo na seção de **Tipos comuns**.
+
 ### OCR
 Por meio do SDK também é possível utilizar a funcionalidade de **OCR** diretamente, que permite extrair as informações dos campos de um documento.
 
@@ -214,6 +229,7 @@ const ocrResponse = await ocr({
 })
 
 ocrResponse.startCamera()
+ocrResponse.captureImage()
 
 // Ou
 
@@ -229,15 +245,29 @@ ocrResponse.sendFile(fileVariable)
 | customId            | Identificador customizado para auditoria. | Não |
 | startTheCameraImmediately | Booleano que determina se a câmera será acionada assim que a função for executada ou se será acionada manualmente depois. Por padrão, a câmera será acionada automaticamente. | Não |
 | onStart             | Função executada quando a verificação for iniciada. <br><br>Disponibiliza pelos parâmetros um objeto contendo a stream da transmissão (**videoStream**), caso disponível. | Não |
+| onCameraStart       | Função executada quando a câmera for iniciada. <br><br>Disponibiliza pelos parâmetros um objeto contendo a stream da transmissão (**videoStream**), caso disponível. | Não |
+| onCameraStop        | Função executada quando a câmera for interrompida. | Não |
 | onUpdate            | Função executada toda vez que ocorre uma atualização no status geral (quando alguma operação é iniciada ou concluída, quando ocorre erro, etc.). <br><br>Disponibiliza pelos parâmetros um objeto contendo as informações sobre a situação do processamento (qual o status atual, se está carregando, se existe erro, etc.) | Não |
 | onValidationRequested | Função executada quando o status do processamento é "validation". Retorna informações da requisição para que o usuário consiga fazer a validação manual da requisição | Não |
 | onError             | Função executada quando ocorre um erro. <br><br>Disponibiliza pelos parâmetros a instância do erro, a qual contém um identificador (propriedade **code**). | Não |
-| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br><br>Disponibiliza pelos parâmetros um objeto com os resultados, compostos pelo ID da solicitação (**livenessId**) e pelos frames de sucesso (**successFrames**). | Não |
+| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br><br>Disponibiliza pelos parâmetros um objeto com os resultados. | Não |
 | onEnd               | Função executada quando a verificação é finalizada, seja com erro ou com sucesso. | Não |
 
+#### Retorno da função ocr (JavaScript)
+| Nome da propriedade | Função |
+| ------------------- | ------ |
+| startCamera         | Função para iniciar a câmera manualmente. <br><br>É possível informar nos parâmetros a direção de câmera desejada (**facingMode**), seguindo um modelo semelhante ao das funções de controle de câmera do próprio JavaScript (No mobile, por exemplo, facingMode == 'user' para usar a câmera da frente e facingMode == 'environment' para usar a câmera de trás). <br><br>Por padrão o facingMode é 'user'. |
+| stopCamera          | Função para desligar a câmera manualmente. |
+| captureImage        | Função para capturar a imagem que será utilizada para consumo com a câmera. |
+| getVideoStream      | Função para obter a stream de vídeo da câmera, se ela estiver disponível. |
+| sendFile            | Função para enviar arquivos manualmente, iniciando também o processamento. |
+
 #### Utilização em Node.js
 A utilização da função de OCR em Node.js é idêntica à utilização em JavaScript normal para browsers e ambientes semelhantes, com a exceção das funções e propriedades relacionadas à câmera, que não estão disponíveis nesta versão.
 
+#### Formato dos resultados
+Os resultados podem ser obtidos por meio da função de callback **onSuccess** por meio dos parâmetros. Sua estrutura é baseada na interface **IOcrResult**, a qual pode ser consultada mais abaixo na seção de **Tipos comuns**.
+
 ### Face Match
 Por meio do SDK também é possível utilizar a funcionalidade de **Face Match**, que permite comparar duas faces e verificar se são iguais. É possível enviar uma imagem que contenha dois rostos para comparação, ou enviar duas imagens, com um rosto em cada uma.
 
@@ -291,12 +321,12 @@ const faceMatchResponse = await faceMatch({
   // ...
 })
 
-ocrResponse.startCamera()
+faceMatchResponse.startCamera()
 faceMatchResponse.captureFirstImage()
 
 // Ou
 
-ocrResponse.sendFiles(fileVariable1, fileVariable2)
+faceMatchResponse.sendFiles(fileVariable1, fileVariable2)
 ```
 
 #### Opções para a função faceMatch (JavaScript)
@@ -308,18 +338,83 @@ ocrResponse.sendFiles(fileVariable1, fileVariable2)
 | customId            | Identificador customizado para auditoria. | Não |
 | startTheCameraImmediately | Booleano que determina se a câmera será acionada assim que a função for executada ou se será acionada manualmente depois. Por padrão, a câmera será acionada automaticamente. | Não |
 | onStart             | Função executada quando a verificação for iniciada. <br><br>Disponibiliza pelos parâmetros um objeto contendo a stream da transmissão (**videoStream**), caso disponível. | Não |
+| onCameraStart       | Função executada quando a câmera for iniciada. <br><br>Disponibiliza pelos parâmetros um objeto contendo a stream da transmissão (**videoStream**), caso disponível. | Não |
+| onCameraStop        | Função executada quando a câmera for interrompida. | Não |
 | onUpdate            | Função executada toda vez que ocorre uma atualização no status geral (quando alguma operação é iniciada ou concluída, quando ocorre erro, etc.). <br><br>Disponibiliza pelos parâmetros um objeto contendo as informações sobre a situação do processamento (qual o status atual, se está carregando, se existe erro, etc.) | Não |
 | onValidationRequested | Função executada quando o status do processamento é "validation". Retorna informações da requisição para que o usuário consiga fazer a validação manual da requisição | Não |
 | onError             | Função executada quando ocorre um erro. <br><br>Disponibiliza pelos parâmetros a instância do erro, a qual contém um identificador (propriedade **code**). | Não |
-| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br><br>Disponibiliza pelos parâmetros um objeto com os resultados, compostos pelo ID da solicitação (**livenessId**) e pelos frames de sucesso (**successFrames**). | Não |
+| onSuccess           | Função executada quando a verificação é finalizada com sucesso. <br><br>Disponibiliza pelos parâmetros um objeto com os resultados. | Não |
 | onEnd               | Função executada quando a verificação é finalizada, seja com erro ou com sucesso. | Não |
 
+#### Retorno da função faceMatch (JavaScript)
+| Nome da propriedade | Função |
+| ------------------- | ------ |
+| startCamera         | Função para iniciar a câmera manualmente. <br><br>É possível informar nos parâmetros a direção de câmera desejada (**facingMode**), seguindo um modelo semelhante ao das funções de controle de câmera do próprio JavaScript (No mobile, por exemplo, facingMode == 'user' para usar a câmera da frente e facingMode == 'environment' para usar a câmera de trás). <br><br>Por padrão o facingMode é 'user'. |
+| stopCamera          | Função para desligar a câmera manualmente. |
+| captureFirstImage   | Função para capturar a primeira imagem que será utilizada para o Face Match. <br><br> Por padrão, iniciará o processamento após a captura, porém caso deseje utilizar duas imagens você pode evitar isso utilizando a opção **startProcessing**. |
+| captureSecondImage  | Função para capturar a segunda imagem que será utilizada para o Face Match. <br><br> Por padrão, iniciará o processamento após a captura, porém caso deseje impedir isso você pode utilizar a opção **startProcessing**. |
+| getVideoStream      | Função para obter a stream de vídeo da câmera, se ela estiver disponível. |
+| sendFiles           | Função para enviar arquivos manualmente, iniciando também o processamento. Como o Face Match suporta até 2 arquivos, você pode escolher entre enviar apenas 1 arquivo com dois rostos para análise ou 2 arquivos com 1 rosto em cada. |
+
 #### Utilização em Node.js
 A utilização da função de Face Match em Node.js é idêntica à utilização em JavaScript normal para browsers e ambientes semelhantes, com a exceção das funções e propriedades relacionadas à câmera, que não estão disponíveis nesta versão.
 
+#### Formato dos resultados
+Os resultados podem ser obtidos por meio da função de callback **onSuccess** por meio dos parâmetros. Sua estrutura é baseada na interface **IFaceMatchResult**, a qual pode ser consultada mais abaixo na seção de **Tipos comuns**.
+
 ### Prova de Vida
 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.
 
+Existem duas versões:
+
+| Versão | Função | Situação |
+| --- | --- | --- |
+| v2 | `livenessSession` | **Recomendada.** Usa o AWS Rekognition Face Liveness. |
+| v1 | `livenessDetection` | **Deprecada.** Detector in-house, via WebSocket, com o desafio de cinco posições. Mantida até a migração dos clientes, sem receber evolução. |
+
+#### Prova de Vida v2 (recomendada)
+A v2 é feita em duas partes. O SDK cuida do ciclo de sessão contra a API do SantoiD; a captura — câmera, oval e desafio — é feita pelo componente React `<FaceLivenessDetector>` da AWS, que transmite os frames direto para o Rekognition e por isso não faz parte deste pacote.
+
+O fluxo é:
+
+1. `createSession()` — cria a sessão e devolve o `sessionId`
+2. o `<FaceLivenessDetector>` recebe esse `sessionId` e conduz a captura
+3. `getResults()` — quando o detector avisar que terminou
+
+```ts
+import { livenessSession } from 'santoid-sdk/client/liveness'
+
+const session = livenessSession({
+  token: 'string',
+
+  // Opcional: sem track, a verificação não fica atrelada a um processo
+  track: 'string',
+  customerRequestId: 'string',
+
+  onSessionCreated: (sessionId) => {
+    // Entregue este sessionId ao <FaceLivenessDetector>
+  },
+
+  onResults: (results) => {
+    // results.Status, results.Confidence, results.ReferenceImage, results.AuditImages
+  },
+
+  onError: (error) => {
+    // ...
+  },
+})
+
+const sessionId = await session.createSession()
+
+// Depois que o detector sinalizar o fim da captura:
+const results = await session.getResults()
+```
+
+O `getResults` já espera internamente enquanto o Rekognition ainda avalia — o status fica `CREATED` ou `IN_PROGRESS` por alguns instantes após a captura terminar, e a função só devolve quando sair desse estado (ou após esgotar as tentativas).
+
+#### Prova de Vida v1 (deprecada)
+> **Deprecada.** Use `livenessSession`. Esta seção descreve a versão anterior, mantida para os clientes que ainda não migraram.
+
 #### 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 valores dentro do objeto de opções, como no exemplo abaixo:
 
@@ -366,7 +461,7 @@ As propriedades disponíveis para utilização no objeto de opções estão list
 | onEnd               | Função executada quando a verificação é finalizada, seja com erro ou com sucesso. | Não |
 
 <br>
-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.
+Caso a função seja executada em um navegador (ou ambiente semelhante), 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.
@@ -574,7 +669,53 @@ Em que:
 ```typescript
 type TResultStatuses = 'success' | 'error' | null
 
-interface ITypificationResult {
+type TPositions = 'front' | 'right' | 'left' | 'up' | 'bottom'
+
+interface ILivenessResults {
+  livenessId: string
+  successFrames: Record<TPositions, Blob>
+}
+```
+
+Os tipos **ITypificationResult** e **IFaceMatchResult** podem ser conferidos na seção de **Tipos comuns**, disponível mais a frente na documentação.
+
+#### 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.
+
+Outro detalhe é que no Node.js todos os tipos envolvendo **File** ou **Blob** passam a utilizar valores do tipo **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/server/liveness'
+
+const uploadIdentificationDocumentResponse = uploadIdentificationDocument({
+  token: 'string',
+  track: 'string',
+
+  livenessDetectionOptions: {
+    getNextFrame () {
+      // ...
+    },
+
+    // ...
+  },
+
+  // ...
+})
+```
+
+## Tipos comuns
+Esta seção destina-se a disponibilizar os tipos dos resultados de algumas funções. Algumas funcionalidades possuem resultados com estruturas parecidas internamente.
+
+A tipificação, por exemplo, pode ser configurada para iniciar também o OCR dos campos e, consequentemente, conter resultados de OCR em seu interior.
+
+Por essa razão, para simplificar o entendimento, serão disponibilizados a seguir as interfaces dos resultados dessas funcionalidades de forma simplificada.
+
+### Estrutura base
+```ts
+interface IBaseAsyncResult {
   count: number
   customerRequestId: string
   domain: string
@@ -585,80 +726,115 @@ interface ITypificationResult {
   service: string
   status: string
   track: string
+}
+```
 
-  documents: Array<{
-    typification: {
-      id: string
-      score: number
-    }
+### Resultados da Tipificação
+```ts
+// Resultados completos da tipificação
+interface ITypificationResult extends IBaseAsyncResult {
+  documents: ITypificationDocumentResult[]
+}
 
-    error?: {
+// Resultados para um documento individual
+interface ITypificationDocumentResult {
+  typification: {
+    id: string
+    score: number
+  }
+
+  error?: {
+    message: string
+  }
+
+  ocr?: {
+    template: string
+
+    labels: ICropResult[] | null
+  } | boolean
+}
+```
+
+### Resultados do OCR
+```ts
+// Resultados completos do OCR
+interface IOcrResult extends IBaseAsyncResult {
+  template: string
+
+  documents: IOcrDocumentResult[]
+}
+
+// Resultados para um documento individual
+interface IOcrDocumentResult {
+  error?: {
+    message: string
+  }
+
+  ocr: {
+    template: string
+
+    labels: ICropResult[] | null
+  } | boolean
+}
+
+// Resultados para um único campo
+interface ICropResult {
+  x: number
+  y: number
+  w: number
+  h: number
+  bottomRight: number[]
+  topLeft: number[]
+
+  label: string | null
+
+  text: string | null
+  ocr_score: number | null
+  crop: string | null
+  ocrInterpretive?: boolean | string | null
+
+  ocrList: IOcrListResult[] | null
+
+  serpro_query?: {
+    serpro_data: any
+    search_logs: {
+      document: string
+      type: string
+      search_time: string
+      status_code: number
       message: string
     }
+  } | null
 
-    ocr: {
-      template: string
-
-      labels: Array<{
-        x: number
-        y: number
-        w: number
-        h: number
-        bottomRight: number[]
-        topLeft: number[]
-
-        label: string | null
-
-        text: string | null
-        ocr_score: number | null
-        crop: string | null
-        ocrInterpretive?: boolean | string | null
-        ocrList?: Array<{
-          x: number
-          y: number
-          w: number
-          h: number
-          bottomRight: number[]
-          topLeft: number[]
-
-          dataField?: string
-          dataFieldValue?: boolean
-
-          label: string | null
-          ocr?: string | null
-          ocr_score?: number
-          cropBase64?: string | null
-        }> | null
-
-        serpro_query?: {
-          serpro_data: any
-          search_logs: {
-            document: string
-            type: string
-            search_time: string
-            status_code: number
-            message: string
-          }
-        } | null
-
-        validation: {
-          type: string | null
-          value: number | string | boolean
-        } | null
-
-        validationSerpro?: Record<string, number | boolean>
-      }> | null
-    } | null
-  }>
-}
+  validation: {
+    type: string | null
+    value: number | string | boolean
+  } | null
 
-export type TPositions = 'front' | 'right' | 'left' | 'up' | 'bottom'
+  validationSerpro?: Record<string, number | boolean>
+}
 
-interface ILivenessResults {
-  livenessId: string
-  successFrames: Record<TPositions, Blob>
+// Resultados para os campos internos de um campo com OCR em lista configurado
+interface IOcrListResult {
+  x: number
+  y: number
+  w: number
+  h: number
+  bottomRight: number[]
+  topLeft: number[]
+
+  dataField?: string
+  dataFieldValue?: boolean
+
+  label: string | null
+  ocr?: string | null
+  ocr_score?: number
+  cropBase64?: string | null
 }
+```
 
+### Resultados do Face Match
+```ts
 interface IFaceMatchResult {
   domain: string
   track: string
@@ -677,31 +853,4 @@ interface IFaceMatchResult {
   fileImage1?: string
   fileImage2?: string
 }
-```
-
-#### 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.
-
-Outro detalhe é que no Node.js todos os tipos envolvendo **File** ou **Blob** passam a utilizar valores do tipo **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/server/liveness'
-
-const uploadIdentificationDocumentResponse = uploadIdentificationDocument({
-  token: 'string',
-  track: 'string',
-
-  livenessDetectionOptions: {
-    getNextFrame () {
-      // ...
-    },
-
-    // ...
-  },
-
-  // ...
-})
-```
+```

package/api/AbstractService.d.ts

@@ -12,10 +12,11 @@ export declare class AbstractService {
     serviceOptions: IAbstractServiceOptions;
     baseUrl: string;
     constructor(options: Partial<IBaseSDKOptions>, serviceOptions: IAbstractServiceOptions);
-    request({ contentType, authToken, baseUrl, }?: {
-        contentType?: string | undefined;
-        authToken?: string | undefined;
-        baseUrl?: string | undefined;
+    request({ contentType, authToken, baseUrl, extraHeaders, }?: {
+        contentType?: string;
+        authToken?: string;
+        baseUrl?: string;
+        extraHeaders?: Record<string, string>;
     }): import("axios").AxiosInstance;
 }
 export {};

package/api/AbstractService.js

@@ -13,13 +13,10 @@ class AbstractService {
     }
     request(_a) {
         var _b, _c;
-        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;
+        var { contentType = 'application/json', authToken = this.options.token, baseUrl = (_b = this.options.customApiUrl) !== null && _b !== void 0 ? _b : constants_1.API_GATEWAY_URL, extraHeaders, } = _a === void 0 ? {} : _a;
         const axiosConfig = {
             baseURL: baseUrl,
-            headers: {
-                'Content-Type': contentType,
-                Authorization: `Bearer ${authToken}`,
-            },
+            headers: Object.assign({ 'Content-Type': contentType, Authorization: `Bearer ${authToken}` }, extraHeaders),
         };
         let domain = this.options.domain;
         if (!this.options.domain && this.options.token) {

package/api/ApiFaceMatchService.d.ts

@@ -9,9 +9,6 @@ interface IFaceMatchStatusGetResponse extends Awaited<ReturnType<InstanceType<ty
     fileImage1?: string;
     fileImage2?: string;
 }
-export interface IError {
-    error: string;
-}
 export interface IFaceMatchResult {
     domain: string;
     track: string;
@@ -20,7 +17,9 @@ export interface IFaceMatchResult {
     requestType: string;
     customerRequestId: string;
     executionDatetime: string;
-    error?: IError;
+    error?: {
+        error: string;
+    };
     status: string;
     comparison_score: number;
     similarity_score: number;

package/api/ApiLivenessSessionService.d.ts

@@ -0,0 +1,27 @@
+import { AbstractService } from './AbstractService';
+export interface ILivenessSession {
+    SessionId: string;
+}
+export interface ILivenessBoundingBox {
+    Width?: number;
+    Height?: number;
+    Left?: number;
+    Top?: number;
+}
+export interface ILivenessImage {
+    Bytes?: string;
+    BoundingBox?: ILivenessBoundingBox;
+}
+export interface ILivenessSessionResult {
+    SessionId: string;
+    Status: string;
+    Confidence?: number;
+    ReferenceImage?: ILivenessImage;
+    AuditImages?: ILivenessImage[];
+}
+export declare class ApiLivenessSessionService extends AbstractService {
+    get baseLivenessUrl(): string;
+    private livenessRequest;
+    createSession(customerRequestId?: string): Promise<ILivenessSession>;
+    getSessionResults(sessionId: string): Promise<ILivenessSessionResult>;
+}

package/api/ApiLivenessSessionService.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiLivenessSessionService = void 0;
+const AbstractService_1 = require("./AbstractService");
+const constants_1 = require("../utils/constants");
+class ApiLivenessSessionService extends AbstractService_1.AbstractService {
+    get baseLivenessUrl() {
+        var _a;
+        return (_a = this.options.customApiUrl) !== null && _a !== void 0 ? _a : constants_1.LIVENESS_API_URL;
+    }
+    // O liveness v2 nao fica atras do API Gateway, entao o
+    // x-endpoint-api-userinfo precisa ir explicito: e' ele que o backend le
+    // para autorizar (ver api/deps.py, viewer_user_validation).
+    livenessRequest() {
+        var _a;
+        return this.request({
+            baseUrl: this.baseLivenessUrl,
+            extraHeaders: { 'x-endpoint-api-userinfo': (_a = this.options.token) !== null && _a !== void 0 ? _a : '' },
+        });
+    }
+    async createSession(customerRequestId) {
+        const response = await this.livenessRequest().post('/api/v2/liveness/session', { track: this.options.track, customerRequestId });
+        return response.data;
+    }
+    async getSessionResults(sessionId) {
+        const response = await this.livenessRequest().get(`/api/v2/liveness/session/${sessionId}`, { params: this.options.track ? { track: this.options.track } : undefined });
+        return response.data;
+    }
+}
+exports.ApiLivenessSessionService = ApiLivenessSessionService;

package/api/ApiOcrService.d.ts

@@ -57,5 +57,6 @@ export interface IOcrDocumentResult {
     } | boolean;
 }
 export interface IOcrResult extends IBaseAsyncResult {
+    template: string;
     documents: IOcrDocumentResult[];
 }

package/api/ApiTypificationService.d.ts

@@ -13,7 +13,7 @@ export interface ITypificationDocumentResult {
     error?: {
         message: string;
     };
-    ocr: {
+    ocr?: {
         template: string;
         labels: ICropResult[] | null;
     } | boolean;