santoid-sdk 7.0.0 → 9.0.0

package/client/liveness/methods/uploadIdentificationDocument/Service.d.ts

@@ -1,25 +1,22 @@
 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 { type IBaseSDKOptions, type TCallbackFunction } from '../../../../utils/types';
 import { SDKError } from '../../../../utils/error';
-import { type livenessDetection } from '../livenessDetection';
-export declare class UploadIdentificationDocumentService<TFrameType, TMediaType> {
-    options: IServiceOptions<TFrameType, TMediaType>;
-    internalOptions: IInternalServiceOptions<TFrameType, TMediaType>;
+export declare class UploadIdentificationDocumentService<TFrameType> {
+    options: IServiceOptions<TFrameType>;
     typificationService: ApiTypificationService<TFrameType>;
     faceMatchService: ApiFaceMatchService<TFrameType>;
     results: IUploadIdentificationDocumentResults<TFrameType>;
-    constructor(options: IServiceOptions<TFrameType, TMediaType>, internalOptions: IInternalServiceOptions<TFrameType, TMediaType>);
+    constructor(options: IServiceOptions<TFrameType>);
     getResults(): IUploadIdentificationDocumentResults<TFrameType>;
     updateResults(updatedResults: Partial<IUploadIdentificationDocumentResults<TFrameType>>): Promise<void>;
     updateUploadedDocument(file: TFrameType): void;
     waitForResults(requestId: string): Promise<ITypificationResult>;
     waitForResultsFaceMatch(requestId: string): Promise<IFaceMatchResult>;
     startDocumentUpload(file: TFrameType): Promise<void>;
-    startLivenessDetection(startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): TLivenessDetectionReturn<TMediaType> | undefined;
     startFaceMatch(firstImage: TFrameType, secondImage: TFrameType): Promise<void>;
-    tryStartFaceMatch(): Promise<void>;
-    startAll(file: TFrameType, startLivenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>): void;
+    startFaceComparison(selfie: TFrameType): Promise<void>;
+    startAll(file: TFrameType, selfie?: TFrameType): Promise<void>;
 }
 type TResultStatuses = 'success' | 'error' | null;
 export interface IUploadIdentificationDocumentResults<TFrameType> {
@@ -30,12 +27,6 @@ export interface IUploadIdentificationDocumentResults<TFrameType> {
         loading: boolean;
         error: SDKError | null;
     };
-    liveness: {
-        status: TResultStatuses;
-        results: ILivenessResults<TFrameType | null | undefined> | null;
-        loading: boolean;
-        error: SDKError | null;
-    };
     faceMatch: {
         status: TResultStatuses;
         results: IFaceMatchResult | null;
@@ -43,28 +34,16 @@ export interface IUploadIdentificationDocumentResults<TFrameType> {
         error: SDKError | null;
     };
 }
-type ICustomLivenessOptions<TFrameType, TMediaType> = Omit<ISDKOptions<TFrameType, TMediaType>, 'track' | 'token'> & {
-    track?: string;
-    token?: string;
-};
-export interface IServiceOptions<TFrameType, TMediaType> extends IBaseSDKOptions {
-    livenessDetectionOptions?: ICustomLivenessOptions<TFrameType, TMediaType>;
+export interface IServiceOptions<TFrameType> extends IBaseSDKOptions {
     onUpdate?: (results?: IUploadIdentificationDocumentResults<TFrameType>) => void | Promise<void>;
-    onSuccess?: <TFrameType, ResultsType = ILivenessResults<TFrameType>>(results?: ResultsType) => void | Promise<void>;
+    onSuccess?: <TFrameType, ResultsType = IUploadIdentificationDocumentResults<TFrameType>>(results?: ResultsType) => void | Promise<void>;
     onError?: (error?: SDKError) => void | Promise<void>;
     onEnd?: TCallbackFunction;
     onValidationRequested?: (requestInformation: IRequestInformation) => void | Promise<void>;
     onClearInterval?: (interval: ReturnType<typeof setInterval>) => void | Promise<void>;
 }
-type TLivenessDetectionReturn<TMediaType> = Omit<ReturnType<typeof livenessDetection>, 'getVideoStream'> & {
-    getVideoStream?: () => TMediaType;
-};
-type TLivenessDetectionFn<TFrameType, TMediaType> = (options: ISDKOptions<TFrameType, TMediaType>) => TLivenessDetectionReturn<TMediaType>;
 interface IRequestInformation {
     track: string;
     requestId: string;
 }
-export interface IInternalServiceOptions<TFrameType, TMediaType> {
-    livenessDetection: TLivenessDetectionFn<TFrameType, TMediaType>;
-}
 export {};

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

@@ -7,15 +7,13 @@ const error_1 = require("../../../../utils/error");
 const uuid_1 = require("uuid");
 const index_1 = require("../../utils/index");
 class UploadIdentificationDocumentService {
-    constructor(options, internalOptions) {
+    constructor(options) {
         this.results = {
             uploadedDocument: null,
             typification: { status: null, results: null, loading: false, error: null },
-            liveness: { status: null, results: null, loading: false, error: null },
             faceMatch: { status: null, results: null, loading: false, error: null },
         };
         this.options = options;
-        this.internalOptions = internalOptions;
         this.typificationService = new ApiTypificationService_1.ApiTypificationService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
         this.faceMatchService = new ApiFaceMatchService_1.ApiFaceMatchService(options, { FormDataClass: FormData, tryDecodeJwt: index_1.tryDecodeJwt });
     }
@@ -24,14 +22,15 @@ class UploadIdentificationDocumentService {
     }
     async updateResults(updatedResults) {
         var _a, _b, _c, _d, _e, _f;
-        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));
-        // Prevent Face Match loop
-        if (!updatedResults.faceMatch) {
-            this.tryStartFaceMatch();
-        }
-        if (Object.entries(this.results).every(([key, value]) => key === 'uploadedDocument' || !!value.results)) {
-            await ((_d = (_c = this.options).onSuccess) === null || _d === void 0 ? void 0 : _d.call(_c, this.results));
+        const results = Object.assign(Object.assign({}, this.results), updatedResults);
+        this.results = results;
+        await ((_b = (_a = this.options).onUpdate) === null || _b === void 0 ? void 0 : _b.call(_a, results));
+        // Decide sobre o estado desta atualizacao, nao o de this.results depois do
+        // await: com upload e face match em paralelo, as duas atualizacoes finais
+        // leriam o mesmo estado e o onSuccess sairia duas vezes.
+        const { typification, faceMatch } = results;
+        if (typification.results && !typification.loading && !faceMatch.loading) {
+            await ((_d = (_c = this.options).onSuccess) === null || _d === void 0 ? void 0 : _d.call(_c, results));
             await ((_f = (_e = this.options).onEnd) === null || _f === void 0 ? void 0 : _f.call(_e));
         }
     }
@@ -121,47 +120,6 @@ class UploadIdentificationDocumentService {
             this.updateResults({ typification: { status: 'error', results: null, loading: false, error: adaptedError } });
         }
     }
-    startLivenessDetection(startLivenessDetectionOptions) {
-        var _a, _b;
-        const adaptedLivenessDetection = Object.assign(Object.assign({}, this.options.livenessDetectionOptions), startLivenessDetectionOptions);
-        this.updateResults({ liveness: { results: null, status: null, loading: true, error: null } });
-        try {
-            return this.internalOptions.livenessDetection(Object.assign(Object.assign({ domain: this.options.domain, customId: this.options.customId, customWebSocketUrl: this.options.customWebSocketUrl, token: this.options.token, track: this.options.track }, adaptedLivenessDetection), { onSuccess: async (livenessResults) => {
-                    var _a;
-                    await ((_a = adaptedLivenessDetection === null || adaptedLivenessDetection === void 0 ? void 0 : adaptedLivenessDetection.onSuccess) === null || _a === void 0 ? void 0 : _a.call(adaptedLivenessDetection, livenessResults));
-                    this.updateResults({
-                        liveness: {
-                            status: 'success',
-                            results: (livenessResults),
-                            loading: false,
-                            error: null,
-                        },
-                    });
-                }, onError: async (livenessErrorDetails) => {
-                    var _a, _b, _c;
-                    await ((_a = adaptedLivenessDetection === null || adaptedLivenessDetection === void 0 ? void 0 : adaptedLivenessDetection.onError) === null || _a === void 0 ? void 0 : _a.call(adaptedLivenessDetection, livenessErrorDetails));
-                    await ((_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, livenessErrorDetails));
-                    this.updateResults({
-                        liveness: {
-                            status: 'error',
-                            results: null,
-                            loading: (livenessErrorDetails === null || livenessErrorDetails === void 0 ? void 0 : livenessErrorDetails.code) === 'wrong-position',
-                            error: livenessErrorDetails !== null && livenessErrorDetails !== void 0 ? livenessErrorDetails : null,
-                        },
-                    });
-                } }));
-        }
-        catch (err) {
-            const adaptedError = new error_1.SDKError({
-                message: 'Error during liveness detection',
-                code: error_1.EUploadIdentificationDocumentErrorCodes.LIVENESS_DETECTION_ERROR,
-                fatal: false,
-                details: err,
-            });
-            (_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, adaptedError);
-            this.updateResults({ liveness: { status: 'error', results: null, loading: false, error: adaptedError } });
-        }
-    }
     async startFaceMatch(firstImage, secondImage) {
         var _a, _b;
         try {
@@ -181,26 +139,27 @@ class UploadIdentificationDocumentService {
             this.updateResults({ faceMatch: { results: null, status: 'error', loading: false, error: adaptedError } });
         }
     }
-    async tryStartFaceMatch() {
-        var _a, _b, _c;
-        if (this.results.uploadedDocument &&
-            ((_a = this.results.liveness.results) === null || _a === void 0 ? void 0 : _a.successFrames.front) &&
-            !this.results.faceMatch.loading &&
-            !this.results.liveness.loading &&
-            !this.results.typification.loading) {
-            await this.startFaceMatch(this.results.uploadedDocument, this.results.liveness.results.successFrames.front);
-        }
-        else {
-            await ((_c = (_b = this.options).onError) === null || _c === void 0 ? void 0 : _c.call(_b, new error_1.SDKError({
+    // A selfie vem de quem chama - por exemplo, a foto de referencia da prova de
+    // vida (livenessSession). O documento e' o enviado em startDocumentUpload.
+    async startFaceComparison(selfie) {
+        var _a, _b;
+        if (!this.results.uploadedDocument || !selfie) {
+            await ((_b = (_a = this.options).onError) === null || _b === void 0 ? void 0 : _b.call(_a, new error_1.SDKError({
                 message: 'Unavailable faces',
                 code: error_1.EUploadIdentificationDocumentErrorCodes.FACE_MATCH_UNAVAILABLE_FACES_ERROR,
                 fatal: false,
             })));
+            return;
         }
+        await this.startFaceMatch(this.results.uploadedDocument, selfie);
     }
-    startAll(file, startLivenessDetectionOptions) {
-        this.startDocumentUpload(file);
-        this.startLivenessDetection(startLivenessDetectionOptions);
+    // Em paralelo: o onSuccess so dispara quando nada mais esta carregando, entao
+    // em sequencia ele sairia uma vez sem o face match e outra com ele.
+    async startAll(file, selfie) {
+        await Promise.all([
+            this.startDocumentUpload(file),
+            selfie ? this.startFaceComparison(selfie) : undefined,
+        ]);
     }
 }
 exports.UploadIdentificationDocumentService = UploadIdentificationDocumentService;

package/client/liveness/methods/uploadIdentificationDocument/index.d.ts

@@ -1,22 +1,8 @@
 import { type IServiceOptions } from './Service';
-import { type TFrameType, type TMediaType } from '../livenessDetection';
-export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType, TMediaType>): {
+export type TFrameType = File | Blob;
+export declare function uploadIdentificationDocument(options: IServiceOptions<TFrameType>): {
     startDocumentUpload: (file: TFrameType) => Promise<void>;
-    startLivenessDetection: (startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "track" | "token"> & {
-        track?: string | undefined;
-        token?: string | undefined;
-    }) | undefined) => (Omit<{
-        getVideoStream: () => TMediaType;
-        stopLivenessDetection: () => Promise<void>;
-        resumeGettingFrames: () => void;
-        pauseGettingFrames: () => void;
-    }, "getVideoStream"> & {
-        getVideoStream?: (() => TMediaType) | undefined;
-    }) | undefined;
-    startFaceComparison: () => Promise<void>;
-    startAll: (file: TFrameType, startLivenessDetectionOptions?: (Omit<import("../../../../utils/types").ISDKOptions<TFrameType, TMediaType>, "track" | "token"> & {
-        track?: string | undefined;
-        token?: string | undefined;
-    }) | undefined) => void;
+    startFaceComparison: (selfie: TFrameType) => Promise<void>;
+    startAll: (file: TFrameType, selfie?: TFrameType | undefined) => Promise<void>;
     getResults: () => import("./Service").IUploadIdentificationDocumentResults<TFrameType>;
 };

package/client/liveness/methods/uploadIdentificationDocument/index.js

@@ -2,21 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadIdentificationDocument = void 0;
 const Service_1 = require("./Service");
-const livenessDetection_1 = require("../livenessDetection");
 function uploadIdentificationDocument(options) {
-    const uploadIdentificationDocumentService = new Service_1.UploadIdentificationDocumentService(options, { livenessDetection: livenessDetection_1.livenessDetection });
+    const uploadIdentificationDocumentService = new Service_1.UploadIdentificationDocumentService(options);
     return {
         startDocumentUpload: async (...rest) => {
             await uploadIdentificationDocumentService.startDocumentUpload(...rest);
         },
-        startLivenessDetection: (...rest) => {
-            return uploadIdentificationDocumentService.startLivenessDetection(...rest);
-        },
         startFaceComparison: async (...rest) => {
-            await uploadIdentificationDocumentService.tryStartFaceMatch(...rest);
+            await uploadIdentificationDocumentService.startFaceComparison(...rest);
         },
-        startAll: (...rest) => {
-            uploadIdentificationDocumentService.startAll(...rest);
+        startAll: async (...rest) => {
+            await uploadIdentificationDocumentService.startAll(...rest);
         },
         getResults: (...rest) => {
             return uploadIdentificationDocumentService.getResults(...rest);

package/client/liveness-capture/LivenessCapture.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export type TLivenessCaptureLanguage = 'pt' | 'en';
+export type TLivenessCaptureColorMode = 'light' | 'dark';
+export interface ILivenessCaptureProps {
+    sessionId: string;
+    region: string;
+    language: TLivenessCaptureLanguage;
+    colorMode: TLivenessCaptureColorMode;
+    onComplete: () => void;
+    onError: (message: string, details: unknown) => void;
+    onCancel: () => void;
+}
+export declare function LivenessCapture({ sessionId, region, language, colorMode, onComplete, onError, onCancel, }: ILivenessCaptureProps): import("react").JSX.Element;

package/client/liveness-capture/LivenessCapture.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivenessCapture = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const ui_react_liveness_1 = require("@aws-amplify/ui-react-liveness");
+const ui_react_1 = require("@aws-amplify/ui-react");
+const displayText_1 = require("./displayText");
+const captureTheme = (0, ui_react_1.createTheme)({
+    name: 'santoid-liveness-capture',
+    overrides: [ui_react_1.defaultDarkModeOverride],
+});
+// Em ingles valem os textos padrao do componente.
+const displayTextByLanguage = {
+    pt: displayText_1.portugueseDisplayText,
+    en: undefined,
+};
+function LivenessCapture({ sessionId, region, language, colorMode, onComplete, onError, onCancel, }) {
+    return ((0, jsx_runtime_1.jsx)(ui_react_1.ThemeProvider, { theme: captureTheme, colorMode: colorMode, children: (0, jsx_runtime_1.jsx)(ui_react_liveness_1.FaceLivenessDetector, { sessionId: sessionId, region: region, displayText: displayTextByLanguage[language], onAnalysisComplete: async () => { onComplete(); }, onUserCancel: onCancel, onError: (captureError) => {
+                var _a, _b;
+                onError(`${captureError.state}: ${(_b = (_a = captureError.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'capture failed'}`, captureError);
+            } }) }));
+}
+exports.LivenessCapture = LivenessCapture;

package/client/liveness-capture/displayText.d.ts

@@ -0,0 +1,54 @@
+export declare const portugueseDisplayText: {
+    readonly cameraMinSpecificationsHeadingText: "Câmera não atende aos requisitos mínimos";
+    readonly cameraMinSpecificationsMessageText: "A câmera precisa suportar ao menos 320x240 e 15 quadros por segundo.";
+    readonly cameraNotFoundHeadingText: "Câmera não encontrada";
+    readonly cameraNotFoundMessageText: "Verifique se há uma câmera conectada e se o navegador tem permissão de acesso.";
+    readonly retryCameraPermissionsText: "Tentar novamente";
+    readonly waitingCameraPermissionText: "Aguardando permissão de acesso à câmera...";
+    readonly a11yVideoLabelText: "Vídeo da câmera para verificação de vivacidade";
+    readonly photosensitivityWarningHeadingText: "Aviso de fotossensibilidade";
+    readonly photosensitivityWarningBodyText: "Esta verificação exibe luzes coloridas. Tenha cuidado caso você seja fotossensível.";
+    readonly photosensitivityWarningInfoText: "Uma pequena porcentagem de pessoas pode ter convulsões ao ser exposta a luzes coloridas. Tenha cuidado se você ou alguém da sua família tiver epilepsia.";
+    readonly photosensitivityWarningLabelText: "Mais informações";
+    readonly goodFitCaptionText: "Enquadramento correto";
+    readonly goodFitAltText: "Rosto totalmente dentro do oval.";
+    readonly tooFarCaptionText: "Muito distante";
+    readonly tooFarAltText: "Rosto pequeno e distante do oval.";
+    readonly startScreenBeginCheckText: "Iniciar verificação";
+    readonly hintMoveFaceFrontOfCameraText: "Posicione o rosto em frente à câmera";
+    readonly hintTooManyFacesText: "Mantenha apenas um rosto em frente à câmera";
+    readonly hintFaceDetectedText: "Rosto detectado";
+    readonly hintCanNotIdentifyText: "Rosto não identificado";
+    readonly hintTooCloseText: "Afaste-se um pouco";
+    readonly hintTooFarText: "Aproxime-se";
+    readonly hintHoldFaceForFreshnessText: "Permaneça parado";
+    readonly hintConnectingText: "Conectando...";
+    readonly hintVerifyingText: "Verificando...";
+    readonly hintCheckCompleteText: "Verificação concluída";
+    readonly hintIlluminationTooBrightText: "Vá para um ambiente com menos luz";
+    readonly hintIlluminationTooDarkText: "Vá para um ambiente mais iluminado";
+    readonly hintIlluminationNormalText: "Iluminação adequada";
+    readonly hintCenterFaceText: "Centralize seu rosto";
+    readonly hintCenterFaceInstructionText: "Instrução: centralize o rosto no oval durante a verificação.";
+    readonly hintFaceOffCenterText: "Rosto fora do oval. Centralize-o.";
+    readonly hintMatchIndicatorText: "de enquadramento concluído";
+    readonly recordingIndicatorText: "Gravando";
+    readonly cancelLivenessCheckText: "Cancelar verificação";
+    readonly errorLabelText: "Erro";
+    readonly connectionTimeoutHeaderText: "Tempo de conexão esgotado";
+    readonly connectionTimeoutMessageText: "A conexão está lenta demais para concluir a verificação. Tente novamente.";
+    readonly timeoutHeaderText: "Tempo esgotado";
+    readonly timeoutMessageText: "O rosto não preencheu o oval a tempo. Tente novamente e mantenha o rosto dentro do oval.";
+    readonly faceDistanceHeaderText: "Falha na verificação";
+    readonly faceDistanceMessageText: "Evite aproximar-se demais durante a contagem.";
+    readonly multipleFacesHeaderText: "Falha na verificação";
+    readonly multipleFacesMessageText: "Mais de um rosto detectado. Certifique-se de que apenas um rosto esteja visível.";
+    readonly clientHeaderText: "Erro no cliente";
+    readonly clientMessageText: "A verificação falhou devido a um problema no dispositivo.";
+    readonly serverHeaderText: "Erro no servidor";
+    readonly serverMessageText: "Não foi possível concluir a verificação por um erro no servidor.";
+    readonly landscapeHeaderText: "Orientação não suportada";
+    readonly landscapeMessageText: "Gire o dispositivo para o modo retrato.";
+    readonly portraitMessageText: "Use o dispositivo em modo retrato durante a verificação.";
+    readonly tryAgainText: "Tentar novamente";
+};

package/client/liveness-capture/displayText.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portugueseDisplayText = void 0;
+exports.portugueseDisplayText = {
+    cameraMinSpecificationsHeadingText: 'Câmera não atende aos requisitos mínimos',
+    cameraMinSpecificationsMessageText: 'A câmera precisa suportar ao menos 320x240 e 15 quadros por segundo.',
+    cameraNotFoundHeadingText: 'Câmera não encontrada',
+    cameraNotFoundMessageText: 'Verifique se há uma câmera conectada e se o navegador tem permissão de acesso.',
+    retryCameraPermissionsText: 'Tentar novamente',
+    waitingCameraPermissionText: 'Aguardando permissão de acesso à câmera...',
+    a11yVideoLabelText: 'Vídeo da câmera para verificação de vivacidade',
+    photosensitivityWarningHeadingText: 'Aviso de fotossensibilidade',
+    photosensitivityWarningBodyText: 'Esta verificação exibe luzes coloridas. Tenha cuidado caso você seja fotossensível.',
+    photosensitivityWarningInfoText: 'Uma pequena porcentagem de pessoas pode ter convulsões ao ser exposta a luzes coloridas. Tenha cuidado se você ou alguém da sua família tiver epilepsia.',
+    photosensitivityWarningLabelText: 'Mais informações',
+    goodFitCaptionText: 'Enquadramento correto',
+    goodFitAltText: 'Rosto totalmente dentro do oval.',
+    tooFarCaptionText: 'Muito distante',
+    tooFarAltText: 'Rosto pequeno e distante do oval.',
+    startScreenBeginCheckText: 'Iniciar verificação',
+    hintMoveFaceFrontOfCameraText: 'Posicione o rosto em frente à câmera',
+    hintTooManyFacesText: 'Mantenha apenas um rosto em frente à câmera',
+    hintFaceDetectedText: 'Rosto detectado',
+    hintCanNotIdentifyText: 'Rosto não identificado',
+    hintTooCloseText: 'Afaste-se um pouco',
+    hintTooFarText: 'Aproxime-se',
+    hintHoldFaceForFreshnessText: 'Permaneça parado',
+    hintConnectingText: 'Conectando...',
+    hintVerifyingText: 'Verificando...',
+    hintCheckCompleteText: 'Verificação concluída',
+    hintIlluminationTooBrightText: 'Vá para um ambiente com menos luz',
+    hintIlluminationTooDarkText: 'Vá para um ambiente mais iluminado',
+    hintIlluminationNormalText: 'Iluminação adequada',
+    hintCenterFaceText: 'Centralize seu rosto',
+    hintCenterFaceInstructionText: 'Instrução: centralize o rosto no oval durante a verificação.',
+    hintFaceOffCenterText: 'Rosto fora do oval. Centralize-o.',
+    hintMatchIndicatorText: 'de enquadramento concluído',
+    recordingIndicatorText: 'Gravando',
+    cancelLivenessCheckText: 'Cancelar verificação',
+    errorLabelText: 'Erro',
+    connectionTimeoutHeaderText: 'Tempo de conexão esgotado',
+    connectionTimeoutMessageText: 'A conexão está lenta demais para concluir a verificação. Tente novamente.',
+    timeoutHeaderText: 'Tempo esgotado',
+    timeoutMessageText: 'O rosto não preencheu o oval a tempo. Tente novamente e mantenha o rosto dentro do oval.',
+    faceDistanceHeaderText: 'Falha na verificação',
+    faceDistanceMessageText: 'Evite aproximar-se demais durante a contagem.',
+    multipleFacesHeaderText: 'Falha na verificação',
+    multipleFacesMessageText: 'Mais de um rosto detectado. Certifique-se de que apenas um rosto esteja visível.',
+    clientHeaderText: 'Erro no cliente',
+    clientMessageText: 'A verificação falhou devido a um problema no dispositivo.',
+    serverHeaderText: 'Erro no servidor',
+    serverMessageText: 'Não foi possível concluir a verificação por um erro no servidor.',
+    landscapeHeaderText: 'Orientação não suportada',
+    landscapeMessageText: 'Gire o dispositivo para o modo retrato.',
+    portraitMessageText: 'Use o dispositivo em modo retrato durante a verificação.',
+    tryAgainText: 'Tentar novamente',
+};

package/client/liveness-capture/index.d.ts

@@ -0,0 +1,36 @@
+import '@aws-amplify/ui-react/styles.css';
+import { type TLivenessCaptureColorMode, type TLivenessCaptureLanguage } from './LivenessCapture';
+import { type TLivenessSessionOptions } from '../liveness/methods/livenessSession';
+import { isLivenessApproved } from '../liveness/methods/livenessSession/isLivenessApproved';
+import { type ILivenessSessionResult } from '../../api/ApiLivenessSessionService';
+import { SDKError } from '../../utils/error';
+export { isLivenessApproved };
+export type { TLivenessCaptureColorMode, TLivenessCaptureLanguage };
+export interface ILivenessCaptureResult extends ILivenessSessionResult {
+    approved: boolean;
+    threshold: number;
+}
+export type TMountLivenessOptions = Omit<TLivenessSessionOptions, 'onResults' | 'onError'> & {
+    language?: TLivenessCaptureLanguage;
+    colorMode?: TLivenessCaptureColorMode;
+    /** Confianca minima para `approved`. Padrao: 80. */
+    threshold?: number;
+    /** A captura terminou e o resultado esta sendo consultado. */
+    onCaptureComplete?: () => void | Promise<void>;
+    onResult?: (result: ILivenessCaptureResult) => void | Promise<void>;
+    onError?: (error: SDKError) => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+};
+/**
+ * Monta a captura da prova de vida dentro de `element`.
+ *
+ * Cria a sessao, abre a camera, busca o resultado e entrega em `onResult`
+ * com `approved` ja calculado. Funciona em qualquer pagina - com ou sem
+ * framework -, porque a captura roda isolada dentro do elemento.
+ *
+ * O elemento precisa de altura: a captura ocupa o espaco que ele oferece.
+ */
+export declare function mountLiveness(element: HTMLElement, options: TMountLivenessOptions): {
+    getSessionId: () => string | null;
+    unmount: () => void;
+};