@neofaceid/web-sdk 1.24.1 → 1.25.5

package/dist/index.d.ts

@@ -0,0 +1,1367 @@
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { z } from 'zod';
+
+/**
+ * Application registration data
+ */
+export declare interface ApplicationRegistrationData {
+    applicationName: string;
+    domain: string;
+    acceptOnlyEmailWithSameDomain: boolean;
+}
+
+/**
+ * Application registration result.
+ * `app_token` só vem na criação/rotação; em GETs de leitura vem só `app_token_last4`.
+ */
+export declare interface ApplicationRegistrationResult {
+    success: boolean;
+    application: {
+        id: string;
+        application_name: string;
+        domain: string;
+        accept_only_email_with_same_domain: boolean;
+        app_token?: string;
+        app_token_last4?: string;
+        is_active: boolean;
+        created_at: string;
+    };
+    message: string;
+}
+
+export declare interface AuthorizationOptions {
+    onProgress?: (step: number, totalSteps: number, instruction: string) => void;
+    onPhotoTaken?: (photoNumber: number, blob: Blob) => void;
+    captureDelay?: number;
+}
+
+export declare interface AuthorizationResult {
+    success: boolean;
+    authorizationHash?: string;
+    name?: string;
+    birthDate?: string;
+    cpf?: string;
+    confidenceScore?: number;
+    message?: string;
+}
+
+/**
+ * NEO-108: Authorization operation with multi-photo capture and gesture detection
+ *
+ * This function captures 4 sequential photos for authorization:
+ * - Photo 1: Front face
+ * - Photo 2: Left profile
+ * - Photo 3: Right profile
+ * - Photo 4: Thumbs up gesture with front face
+ *
+ * @param applicationToken The application token for authentication
+ * @param cpf The CPF of the person to authorize
+ * @param options Optional configuration for progress callbacks and delays
+ * @returns Promise with authorization result
+ * @throws NeoFaceError if capture or recognition fails
+ */
+export declare const authorizeOperation: (applicationToken: string, cpf: string, options?: AuthorizationOptions) => Promise<AuthorizationResult>;
+
+export declare class BiometricCaptureModal {
+    private modal;
+    private video;
+    private canvas;
+    private stream;
+    private options;
+    private countdownInterval;
+    private isCapturing;
+    constructor(options: BiometricCaptureOptions);
+    /**
+     * Abre o modal de captura biométrica
+     */
+    open(): Promise<void>;
+    /**
+     * Fecha o modal e limpa recursos
+     */
+    close(): void;
+    /**
+     * Cria a estrutura HTML do modal
+     */
+    private createModal;
+    /**
+     * Inicializa a câmera
+     */
+    private initializeCamera;
+    /**
+     * Inicia a contagem regressiva
+     */
+    private startCountdown;
+    /**
+     * Captura a imagem da câmera
+     */
+    private captureImage;
+    /**
+     * Detecta o tipo biométrico na imagem (face ou mão)
+     */
+    private detectBiometricType;
+    /**
+     * Adiciona event listeners aos elementos do modal
+     */
+    private addEventListeners;
+    /**
+     * Limpa recursos (câmera, intervalos, etc.)
+     */
+    private cleanup;
+    /**
+     * Retorna o título padrão baseado no modo
+     */
+    private getDefaultTitle;
+    /**
+     * Retorna o subtítulo padrão baseado no modo
+     */
+    private getDefaultSubtitle;
+    /**
+     * Adiciona estilos CSS ao modal
+     */
+    private addStyles;
+}
+
+declare interface BiometricCaptureOptions {
+    mode: 'face' | 'hand' | 'auto';
+    onSuccess: (imageData: string, detectedType: 'face' | 'hand') => void;
+    onError: (error: NeoFaceError) => void;
+    onCancel?: () => void;
+    countdown?: number;
+    title?: string;
+    subtitle?: string;
+}
+
+/**
+ * Função de conveniência para login biométrico simples
+ * @param applicationToken Token da aplicação
+ * @param mode Modo de captura ('face', 'hand' ou 'auto')
+ * @returns Promise que resolve com o resultado do login
+ */
+export declare function biometricLogin(applicationToken: string, mode?: 'face' | 'hand' | 'auto'): Promise<BiometricLoginResult>;
+
+export declare interface BiometricLoginOptions {
+    applicationToken: string;
+    onSuccess: (result: BiometricLoginResult) => void;
+    onError: (error: NeoFaceError) => void;
+    onCancel?: () => void;
+    onFallbackRequest?: () => void;
+    countdown?: number;
+    title?: string;
+    subtitle?: string;
+}
+
+export declare type BiometricLoginResult = z.infer<typeof BiometricLoginResultSchema>;
+
+declare const BiometricLoginResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    accessToken: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        role: z.ZodString;
+        validated: z.ZodBoolean;
+        active: z.ZodBoolean;
+    }, z.core.$strip>>;
+    person: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        birth_date: z.ZodString;
+    }, z.core.$strip>>;
+    confidence_score: z.ZodOptional<z.ZodNumber>;
+    recognition_id: z.ZodOptional<z.ZodString>;
+    task_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * Inicia o processo de login biométrico com fallback para email e senha se não houver match (assumindo purpose LOGIN).
+ * @param applicationToken Token da aplicação
+ * @param mode Modo de captura ('face', 'hand' ou 'auto')
+ * @returns Promise que resolve com o resultado do login
+ */
+export declare function biometricLoginWithFallback(applicationToken: string, mode?: 'face' | 'hand' | 'auto'): Promise<BiometricLoginResult>;
+
+declare interface BiometricRegistrationCallbacks {
+    onSuccess(result: BiometricRegistrationResult): void;
+    onError(code: string, message: string): void;
+}
+
+export declare function BiometricRegistrationModal({ personData, applicationToken, onClose, onSuccess, onPhotosCaptured, onError, }: BiometricRegistrationModalProps): JSX_2.Element;
+
+declare interface BiometricRegistrationModalProps {
+    personData?: {
+        name: string;
+        birth_date: string;
+        cpf: string;
+        email: string;
+        password: string;
+    };
+    applicationToken?: string;
+    onClose: () => void;
+    onSuccess?: (result: BiometricRegistrationResult_2) => void;
+    onPhotosCaptured?: (photos: Blob[]) => void;
+    onError: (error: string) => void;
+    useRealApi?: boolean;
+}
+
+declare interface BiometricRegistrationResult {
+    success: boolean;
+    message: string;
+    person_id?: string;
+    user_id?: string;
+    person_validated?: boolean;
+    face_processing?: any;
+    onboarding_link?: string;
+}
+
+declare interface BiometricRegistrationResult_2 {
+    success: boolean;
+    message: string;
+    person_id?: string;
+    user_id?: string;
+    person_validated?: boolean;
+    face_processing?: any;
+    onboarding_link?: string;
+}
+
+/**
+ * Overlay minimalista estilo FaceID para login biométrico
+ * Implementação vanilla JS (sem React) para evitar conflitos de versão
+ */
+export declare class BiometricStatusOverlay {
+    private container;
+    private currentStatus;
+    private getStyles;
+    private getStatusText;
+    private renderContent;
+    show(status?: OverlayStatus): void;
+    updateStatus(status: OverlayStatus): void;
+    close(): void;
+}
+
+declare interface Callbacks {
+    onSuccess(user: {
+        name: string;
+        email: string;
+        documentId: string;
+    }): void;
+    onError(code: string, message: string): void;
+}
+
+/**
+ * Options for capturing face frames
+ */
+export declare interface CaptureFaceFramesOptions {
+    numFrames: number;
+    livenessCheck: boolean;
+}
+
+/**
+ * Check if a user exists by email or CPF
+ * @param params Object with email or cpf to check (only one at a time)
+ * @returns Promise with existence status
+ * @throws NeoFaceError if verification fails
+ *
+ * @example
+ * ```typescript
+ * const result = await checkUserExistence({ email: 'user@example.com' });
+ * if (result.data.exists) {
+ *   console.log('User already exists');
+ * }
+ * ```
+ */
+export declare const checkUserExistence: (params: {
+    email?: string;
+    cpf?: string;
+}) => Promise<UserExistenceResult>;
+
+/**
+ * Conclui o processo de onboarding enviando imagens de face e documento
+ * @param applicationToken Token da aplicação (header `X-App-Token`)
+ * @param onboardingToken Token do link de onboarding
+ * @param faceImage Blob da imagem de rosto
+ * @param documentImage Blob da imagem do documento
+ * @returns Resposta da conclusão do onboarding
+ * @throws NeoFaceError em caso de falha de rede ou validação
+ */
+export declare const completeOnboarding: (applicationToken: string, onboardingToken: string, faceImage: Blob, documentImage: Blob) => Promise<{
+    success: boolean;
+    message: string;
+    person_id?: string;
+    identity_data_id?: string;
+    confidence_score?: number;
+    processing_time?: number;
+}>;
+
+/**
+ * Conclui o processo de onboarding com dados completos da pessoa
+ *
+ * RECEBE:
+ * - Nome, DataDeNascimento, CPF, CNPJ, Email
+ * - Imagens da Pessoa (array de Blobs)
+ * - Imagem do documento
+ *
+ * AÇÃO (backend):
+ * - Se não é cadastrado no NeoFaceId, cadastra-o
+ * - Escaneia o documento e confere com os dados passados
+ * - Confere se a imagem/vídeo passa nos critérios de prova de vida
+ *
+ * @param applicationToken Token da aplicação (header `X-App-Token`)
+ * @param onboardingToken Token do link de onboarding
+ * @param personData Dados da pessoa (Nome, DataDeNascimento, CPF, CNPJ, Email)
+ * @param personImages Array de imagens/vídeos da pessoa para prova de vida (mínimo 1)
+ * @param documentImage Blob da imagem do documento
+ * @returns Resposta da conclusão do onboarding
+ * @throws NeoFaceError em caso de falha de rede ou validação
+ */
+export declare const completeOnboardingWithData: (applicationToken: string, onboardingToken: string, personData: OnboardingPersonData, personImages: Blob[], documentImage: Blob) => Promise<{
+    success: boolean;
+    message: string;
+    person_id?: string;
+    identity_data_id?: string;
+    confidence_score?: number;
+    processing_time?: number;
+    liveness_passed?: boolean;
+    document_verified?: boolean;
+    person_created?: boolean;
+}>;
+
+/**
+ * Confirm password reset using token
+ * @param token Reset token received via email
+ * @param new_password New password
+ */
+export declare function confirmPasswordReset(token: string, new_password: string): Promise<{
+    message: string;
+}>;
+
+export declare interface ConsentInfo {
+    purpose: string;
+    legalBasis: string;
+    privacyPolicyUrl: string;
+    retentionDays: number;
+}
+
+/**
+ * Gerencia o ciclo de vida (montagem/desmontagem) do modal de consentimento.
+ */
+export declare class ConsentModal {
+    private container;
+    private root;
+    show(props: ConsentModalProps): void;
+    close(): void;
+}
+
+/**
+ * Props do modal de consentimento LGPD exibido antes de qualquer captura de câmera.
+ */
+export declare interface ConsentModalProps {
+    purpose: string;
+    legalBasis: string;
+    privacyPolicyUrl: string;
+    retentionDays: number;
+    onAccept: () => void;
+    onDecline: () => void;
+}
+
+/**
+ * Defaults conservadores usados enquanto `SDKInitOptions` não expõe `consent` (US7.2).
+ * Quando essa opção existir, este helper passa a ler `getConfig().consent`.
+ */
+export declare const DEFAULT_CONSENT_INFO: ConsentInfo;
+
+/**
+ * Detecta automaticamente o tipo biométrico na imagem
+ * @param imageData Dados da imagem em base64
+ * @returns Resultado da detecção com tipo e confiança
+ */
+export declare function detectBiometricType(imageData: string): Promise<DetectionResult>;
+
+/**
+ * Módulo de detecção automática de tipo biométrico
+ * Utiliza face-api.js para detectar se a imagem contém face ou mão
+ */
+export declare interface DetectionResult {
+    type: 'face' | 'hand' | 'unknown';
+    confidence: number;
+    details?: any;
+}
+
+export declare class DocumentCaptureModal {
+    private overlay;
+    private video;
+    private canvas;
+    private stream;
+    private resolvePromise;
+    private options;
+    private selectedDocument;
+    private currentStep;
+    private frontBlob;
+    private backBlob;
+    constructor(options?: DocumentCaptureOptions);
+    open(): Promise<DocumentCaptureResult>;
+    private render;
+    private createOverlay;
+    private renderSelectStep;
+    private renderCaptureStep;
+    private renderPreviewStep;
+    private renderBranding;
+    private bindSelectEvents;
+    private bindCaptureEvents;
+    private handleFileUpload;
+    private compressUploadedImage;
+    private bindPreviewEvents;
+    private bindCloseEvent;
+    private startCamera;
+    private stopCamera;
+    private handleCapture;
+    private handleBack;
+    private handleRetake;
+    private handleConfirm;
+    private handleCancel;
+    private close;
+    private getStyles;
+}
+
+export declare interface DocumentCaptureOptions {
+    title?: string;
+    subtitle?: string;
+    useBackCamera?: boolean;
+    onCancel?: () => void;
+    preSelectedDocument?: DocumentType_2;
+}
+
+export declare interface DocumentCaptureResult {
+    success: boolean;
+    documentType?: DocumentType_2;
+    frontImage: Blob | null;
+    backImage: Blob | null;
+    error?: string;
+}
+
+/**
+ * Modal de captura de documento para validação de identidade
+ * Suporta RG, CNH e CPF com etapas de frente e verso quando aplicável
+ */
+declare type DocumentType_2 = 'RG' | 'CNH' | 'CPF';
+export { DocumentType_2 as DocumentType }
+
+/**
+ * Modal para entrada de email e senha como fallback para login.
+ */
+export declare class EmailPasswordModal {
+    private options;
+    private modalElement;
+    constructor(options: EmailPasswordOptions);
+    /**
+     * Abre o modal de login com email e senha.
+     */
+    open(): Promise<void>;
+    /**
+     * Fecha o modal.
+     */
+    close(): void;
+    private createModal;
+    private addStyles;
+    private handleSubmit;
+}
+
+export declare interface EmailPasswordOptions {
+    applicationToken: string;
+    onSuccess: (result: BiometricLoginResult) => void;
+    onError: (error: NeoFaceError) => void;
+    onCancel?: () => void;
+    title?: string;
+    subtitle?: string;
+}
+
+/**
+ * SDK Global Configuration
+ *
+ * Este módulo gerencia a configuração global do SDK, permitindo
+ * inicialização com detecção automática de ambiente ou override manual.
+ */
+export declare type Environment = 'development' | 'sandbox' | 'production';
+
+/**
+ * Mapeamento de ambientes para URLs base da API
+ */
+export declare const ENVIRONMENT_URLS: Record<Environment, string>;
+
+/**
+ * Tipos padronizados de erro do SDK NeoFace ID.
+ * Utilize estes tipos para categorizar e tratar erros de forma consistente.
+ */
+export declare enum ErrorType {
+    NETWORK = "NetworkError",
+    NETWORK_ERROR = "NetworkError",
+    INVALID_TOKEN = "InvalidTokenError",
+    RECOGNITION_FAILED = "RecognitionFailedError",
+    LOGIN_FAILED = "LoginFailedError",
+    VALIDATION_ERROR = "ValidationError",
+    API_ERROR = "ApiError",
+    PERSON_NOT_FOUND = "PersonNotFoundError",
+    INITIALIZATION_ERROR = "InitializationError",
+    CAMERA_ERROR = "CameraError",
+    NO_CAMERA = "NoCameraError",
+    CAPTURE_ERROR = "CaptureError",
+    NOT_FOUND = "NotFoundError",
+    UNKNOWN = "UnknownError",
+    CONSENT_DENIED = "ConsentDeniedError"
+}
+
+export declare function FaceCaptureModal({ accessToken, onClose, onSuccess }: FaceCaptureModalProps): JSX_2.Element;
+
+declare interface FaceCaptureModalProps {
+    accessToken: string;
+    onClose: () => void;
+    onSuccess: (result: RecognitionResult) => void;
+}
+
+/**
+ * Classe para gerenciar o prompt de fallback
+ */
+export declare class FallbackPrompt {
+    private container;
+    private root;
+    /**
+     * Exibe o prompt de fallback
+     */
+    show(error: NeoFaceError | undefined, onRetry: () => void, onCredentials: () => void, onCancel?: () => void, applicationToken?: string): void;
+    /**
+     * Fecha o prompt
+     */
+    close(): void;
+    /**
+     * Renderiza o componente
+     */
+    private render;
+}
+
+/**
+ * Modal de recuperação de senha — self-contained, sem dependência de rotas externas.
+ * Segue o mesmo padrão visual do EmailPasswordModal (vanilla JS, overlay dark).
+ */
+export declare class ForgotPasswordModal {
+    private applicationToken;
+    private modalElement;
+    constructor(applicationToken: string);
+    open(): void;
+    close(): void;
+    private renderEmailForm;
+    private renderSuccess;
+    private handleSubmit;
+    private addStyles;
+}
+
+/**
+ * Retorna o token de aplicação configurado, se houver.
+ */
+export declare function getApplicationToken(): string | null;
+
+/**
+ * Retorna a URL base configurada para a API.
+ * Se o SDK não foi inicializado, retorna o fallback para sandbox.
+ */
+export declare function getBaseUrl(): string;
+
+/**
+ * Retorna toda a configuração atual (para debug).
+ */
+export declare function getConfig(): Readonly<SDKConfig>;
+
+/**
+ * Retorna o ambiente atual configurado.
+ */
+export declare function getEnvironment(): Environment | 'custom';
+
+/**
+ * Identifies a person from an image and returns name and age
+ * @param image The image blob to process
+ * @param applicationToken The application token for authentication
+ * @returns Promise with person name and age
+ * @throws NeoFaceError if request fails
+ * @throws NeoFaceError if identification fails
+ */
+export declare const identifyPerson: (image: Blob, applicationToken: string) => Promise<{
+    success: boolean;
+    taskId?: string;
+    status?: string;
+    person?: {
+        name: string;
+        birth_date: string;
+    };
+    message?: string;
+}>;
+
+/**
+ * High-level helper that identifies a person and waits for the result (polling)
+ * @param image The image blob to process
+ * @param applicationToken The application token
+ * @param options Polling options (maxRetries, interval)
+ */
+export declare const identifyPersonAsync: (image: Blob, applicationToken: string, options?: {
+    maxRetries?: number;
+    interval?: number;
+}) => Promise<{
+    personFound: boolean;
+    person?: {
+        name: string;
+        birth_date: string;
+    };
+}>;
+
+/**
+ * Inicializa o SDK com as configurações fornecidas.
+ * Deve ser chamado uma vez no início da aplicação, antes de usar qualquer função do SDK.
+ *
+ * @example
+ * ```typescript
+ * import { init } from '@neofaceid/web-sdk';
+ *
+ * // Usando ambiente predefinido
+ * init({ environment: 'production' });
+ *
+ * // Usando URL customizada
+ * init({ baseUrl: 'https://my-custom-api.com' });
+ *
+ * // Com token de aplicação
+ * init({
+ *   environment: 'sandbox',
+ *   applicationToken: 'your-app-token'
+ * });
+ * ```
+ *
+ * @param options Opções de inicialização
+ */
+export declare function init(options?: SDKInitOptions): void;
+
+/**
+ * Inicializa o sistema de detecção biométrica
+ * Carrega bibliotecas e modelos necessários
+ */
+export declare function initializeBiometricDetection(): Promise<void>;
+
+/**
+ * Verifica se o sistema de detecção está disponível
+ * @returns true se a detecção avançada está disponível
+ */
+export declare function isAdvancedDetectionAvailable(): boolean;
+
+/**
+ * Verifica se o SDK foi inicializado.
+ */
+export declare function isInitialized(): boolean;
+
+/**
+ * Options for login recognition
+ */
+export declare interface LoginRecognitionOptions {
+    biometricData: Blob | Blob[];
+    typeOfIdentification: 'FACE' | 'HAND';
+    purpose: 'LOGIN' | 'PROOF_OF_LIFE' | 'AUTHORIZATION' | 'SIMPLE_IDENTIFICATION' | 'SIMPLIFIED_REGISTRATION';
+    confidenceThreshold?: number;
+}
+
+/**
+ * Result of login recognition
+ */
+export declare interface LoginRecognitionResult {
+    success: boolean;
+    personName: string;
+    email: string;
+    cpf: string;
+    signature?: string;
+    sessionId?: string;
+    confidenceScore?: number;
+    accessToken?: string;
+}
+
+/**
+ * Performs biometric login using face recognition
+ * @param image The image blob to process
+ * @param applicationToken The application token for authentication
+ * @returns Promise with login result
+ * @throws NeoFaceError if request fails
+ */
+export declare const loginWithBiometric: (image: Blob, applicationToken: string) => Promise<BiometricLoginResult>;
+
+/**
+ * Performs login using email and password
+ * @param email User's email
+ * @param password User's password
+ * @param applicationToken The application token for authentication
+ /**
+ * @returns Promise with login result
+ * @throws NeoFaceError if request fails
+ */
+export declare const loginWithEmail: (email: string, password: string, applicationToken: string) => Promise<BiometricLoginResult>;
+
+/**
+ * Erro customizado do SDK que carrega um tipo semântico.
+ * Permite aos consumidores diferenciar falhas por categoria com `error.type`.
+ */
+export declare class NeoFaceError extends Error {
+    type: ErrorType;
+    /**
+     * Constrói um erro do SDK com mensagem e tipo categórico.
+     * @param message Mensagem descritiva do erro (pode ser técnica)
+     * @param type Tipo categórico do erro
+     */
+    constructor(message: string, type: ErrorType);
+    /**
+     * Retorna uma mensagem amigável para o usuário final, ocultando termos técnicos.
+     */
+    getFriendlyMessage(): string;
+}
+
+/**
+ * NeoFaceID SDK class for biometric authentication
+ *
+ * This class provides a high-level API for biometric recognition,
+ * supporting both internal use (without signature) and external integrations
+ * (with signature and session data for systems like OpsPay).
+ *
+ * @example
+ * ```typescript
+ * // For external integrations (with signature)
+ * const sdk = new NeoFaceID({
+ *   appToken: 'your-application-token',
+ *   baseUrl: 'https://core.neofaceid.com',
+ *   signature: signatureFromBackend,
+ *   sessionData: {
+ *     email: 'user@example.com',
+ *     cpf: '12345678901',
+ *     sessionId: 'session-uuid-123'
+ *   }
+ * });
+ *
+ * // For internal use (without signature)
+ * const sdk = new NeoFaceID({
+ *   appToken: 'your-application-token'
+ * });
+ * ```
+ */
+export declare class NeoFaceID {
+    private appToken;
+    private signature?;
+    private sessionData?;
+    /**
+     * Creates a new NeoFaceID instance
+     * @param config Configuration object
+     * @throws NeoFaceError if signature format is invalid
+     */
+    constructor(config: NeoFaceIDConfig);
+    /**
+     * Validates the format of a signature
+     * HMAC-SHA256 produces a 64-character hexadecimal string
+     * @param signature The signature to validate
+     * @returns true if valid, false otherwise
+     */
+    private validateSignatureFormat;
+    /**
+     * Captures multiple face frames for biometric recognition
+     * @param options Capture options
+     * @returns Promise that resolves to an array of image blobs
+     * @throws NeoFaceError if capture fails
+     */
+    captureFaceFrames(options: CaptureFaceFramesOptions): Promise<Blob[]>;
+    /**
+     * Performs login recognition using biometric data
+     *
+     * This method is designed for external integrations that require
+     * signature validation and session management.
+     *
+     * @param options Recognition options
+     * @returns Promise that resolves to recognition result
+     * @throws NeoFaceError if recognition fails
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.loginRecognition({
+     *   biometricData: await sdk.captureFaceFrames({
+     *     numFrames: 5,
+     *     livenessCheck: true
+     *   }),
+     *   typeOfIdentification: 'FACE',
+     *   purpose: 'LOGIN',
+     *   confidenceThreshold: 0.8
+     * });
+     *
+     * // Result includes signature and sessionId for callback validation
+     * console.log(result.signature, result.sessionId);
+     * ```
+     */
+    loginRecognition(options: LoginRecognitionOptions): Promise<LoginRecognitionResult>;
+    /**
+     * Register a new application for a consumer
+     *
+     * This method allows authenticated users to register new applications
+     * that will receive their own app_token for API access.
+     *
+     * @param jwtToken JWT authentication token from logged user
+     * @param consumerId Consumer ID (UUID) who will own the application
+     * @param applicationData Application registration data
+     * @returns Promise with registration result including app_token
+     * @throws NeoFaceError if registration fails
+     *
+     * @example
+     * ```typescript
+     * const sdk = new NeoFaceID({
+     *   appToken: 'your-application-token'
+     * });
+     *
+     * const result = await sdk.registerApplication(
+     *   userJwtToken,
+     *   consumerUuid,
+     *   {
+     *     applicationName: 'My New App',
+     *     domain: 'example.com',
+     *     acceptOnlyEmailWithSameDomain: true
+     *   }
+     * );
+     *
+     * // Use the generated app_token for the new application
+     * console.log('New App Token:', result.application.app_token);
+     * ```
+     */
+    registerApplication(jwtToken: string, consumerId: string, applicationData: ApplicationRegistrationData): Promise<ApplicationRegistrationResult>;
+    /**
+     * Performs Proof of Life verification
+     *
+     * This method records a video from the camera, sends it to the backend
+     * for liveness detection and face recognition, and returns the result
+     * with personal data filtered by purpose.
+     *
+     * The process is asynchronous:
+     * 1. Records video from the camera (default 3 seconds)
+     * 2. Converts video to base64 and sends to backend
+     * 3. Backend processes liveness detection and face recognition
+     * 4. Polls for task completion
+     * 5. Returns personal data of the identified person
+     *
+     * @param options Configuration options for the proof of life process
+     * @returns Promise that resolves to ProofOfLifeResult
+     * @throws NeoFaceError if verification fails
+     *
+     * @example
+     * ```typescript
+     * const sdk = new NeoFaceID({
+     *   appToken: 'your-application-token'
+     * });
+     *
+     * const result = await sdk.proofOfLife({
+     *   videoDurationMs: 3000, // 3 seconds
+     *   onRecordingProgress: (progress) => {
+     *     console.log(`Recording: ${progress}%`);
+     *   },
+     *   onTaskStatusChange: (status, progress) => {
+     *     console.log(`Status: ${status}, Progress: ${progress}%`);
+     *   }
+     * });
+     *
+     * if (result.success && result.isLive) {
+     *   console.log('Person verified:', result.personalData);
+     *   console.log('Liveness score:', result.livenessScore);
+     *   console.log('Face recognition score:', result.faceRecognitionScore);
+     * }
+     * ```
+     */
+    /**
+     * Registers document images for an already-registered donor person.
+     *
+     * Opens the document capture UI (front + optional back), then submits
+     * the images to the backend for extraction via DocExt.
+     * The backend processes this asynchronously — use the returned `taskId`
+     * to poll status if needed.
+     *
+     * @param personId UUID of the donor's person record
+     * @param jwtToken JWT Bearer token of the authenticated donor
+     * @param options Optional capture configuration
+     * @returns Promise with task_id and processing status
+     * @throws NeoFaceError if capture is cancelled, validation fails, or API call fails
+     *
+     * @example
+     * ```typescript
+     * const sdk = new NeoFaceID({ appToken: 'your-token' });
+     *
+     * const result = await sdk.registerDocumentByImage(personId, userJwtToken);
+     * console.log('Task ID:', result.taskId); // poll for completion
+     * ```
+     */
+    registerDocumentByImage(personId: string, jwtToken: string, options?: RegisterDocumentByImageOptions): Promise<RegisterDocumentResult>;
+    proofOfLife(options?: ProofOfLifeOptions): Promise<ProofOfLifeResult>;
+}
+
+/**
+ * Configuration for NeoFaceID SDK initialization
+ */
+export declare interface NeoFaceIDConfig {
+    appToken: string;
+    baseUrl?: string;
+    signature?: string;
+    sessionData?: SessionData;
+}
+
+declare interface OnboardingLinkDetails {
+    id: string;
+    token: string;
+    event: string;
+    custom_flow_id?: string | null;
+    expire: boolean;
+    expires_at?: string | null;
+    notification: boolean;
+    callback_url?: string | null;
+    callback_email?: string | null;
+    person_name: string;
+    person_birth_date: string;
+    person_cpf: string;
+    person_email: string;
+    person_phone?: string | null;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    completed_at?: string | null;
+    is_valid: boolean;
+    is_expired: boolean;
+    onboarding_url: string;
+    consumer_name?: string;
+}
+
+/**
+ * Interface para dados da pessoa no onboarding
+ */
+export declare interface OnboardingPersonData {
+    name?: string;
+    birth_date?: string;
+    cpf?: string;
+    cnpj?: string;
+    email?: string;
+}
+
+export declare type OverlayStatus = 'preparing' | 'detecting' | 'waiting-for-face' | 'capturing' | 'verifying' | 'success' | 'error';
+
+/**
+ * Personal data item returned by PROOF_OF_LIFE
+ */
+export declare interface PersonalDataItem {
+    type: string;
+    english_label?: string;
+    value: string;
+    masked: boolean;
+    validated: boolean;
+    is_principal_identification?: boolean;
+    data_classification?: string;
+}
+
+/**
+ * Pré-carrega modelos do face-api.js (chame no início da aplicação)
+ */
+export declare function preloadFaceDetectionModels(): Promise<void>;
+
+/**
+ * Options for Proof of Life verification
+ */
+export declare interface ProofOfLifeOptions {
+    /** Duration of video recording in milliseconds (default: 3000) */
+    videoDurationMs?: number;
+    /** Maximum polling attempts for task status (default: 60) */
+    maxPollingAttempts?: number;
+    /** Interval between polling attempts in ms (default: 1000) */
+    pollingIntervalMs?: number;
+    /** Callback for recording progress (0-100) */
+    onRecordingProgress?: (progress: number) => void;
+    /** Callback for task status changes */
+    onTaskStatusChange?: (status: string, progress?: number) => void;
+}
+
+/**
+ * Result of PROOF_OF_LIFE operation
+ */
+export declare interface ProofOfLifeResult {
+    success: boolean;
+    isLive: boolean;
+    livenessScore: number;
+    faceRecognitionScore: number;
+    combinedConfidence: number;
+    personId?: string;
+    personalData: PersonalDataItem[];
+    processingTime: number;
+    historyId: string;
+    taskId: string;
+    message?: string;
+    error?: string;
+}
+
+declare interface RecognitionResult {
+    success: boolean;
+    data: {
+        faceId: string;
+        confidence: number;
+    };
+}
+
+/**
+ * Recognizes a face from an image and returns user data
+ * @param image The image blob to process
+ * @param applicationToken The application token for authentication
+ * @returns Promise with access token and user payload
+ * @throws NeoFaceError if request fails
+ * @throws NeoFaceError if recognition fails
+ */
+export declare const recognize: (image: Blob, applicationToken: string) => Promise<{
+    accessToken: string;
+    payload: {
+        name: string;
+        email: string;
+        documentId: string;
+    };
+}>;
+
+/**
+ * Performs biometric recognition with liveness check
+ *
+ * Note: person_id is NOT returned for security reasons.
+ * Use recognizeByPurpose for external integrations that require signature validation.
+ *
+ * @param image The image blob to process
+ * @param applicationToken The application token for authentication
+ * @param livenessCheck Whether to perform liveness check (default: true)
+ * @param confidenceThreshold Confidence threshold for recognition (default: 0.8)
+ * @returns Promise with recognition result
+ * @throws NeoFaceError if request fails
+ */
+export declare const recognizeBiometric: (image: Blob, applicationToken: string, livenessCheck?: boolean, confidenceThreshold?: number) => Promise<{
+    success: boolean;
+    confidenceScore?: number;
+    accessToken?: string;
+    payload?: {
+        name: string;
+        email: string;
+        documentId: string;
+    };
+}>;
+
+/**
+ * Performs purpose-specific recognition
+ * @param image The image blob to process
+ * @param applicationToken The application token for authentication
+ * @param purpose Purpose of recognition ('LOGIN', 'PROOF_OF_LIFE', 'AUTHORIZATION', etc.)
+ * @param confidenceThreshold Confidence threshold for recognition (default: 0.8)
+ * @param signature Optional signature for external integrations (HMAC-SHA256 hex string)
+ * @param sessionData Optional session data for external integrations (email, cpf, sessionId)
+ * @returns Promise with recognition result
+ * @throws NeoFaceError if request fails
+ */
+export declare const recognizeByPurpose: (image: Blob, applicationToken: string, purpose: "LOGIN" | "PROOF_OF_LIFE" | "AUTHORIZATION" | "SIMPLE_IDENTIFICATION" | "SIMPLIFIED_REGISTRATION", confidenceThreshold?: number, signature?: string, sessionData?: SessionData) => Promise<{
+    success: boolean;
+    personName?: string;
+    email?: string;
+    cpf?: string;
+    confidenceScore?: number;
+    accessToken?: string;
+    payload?: any;
+    signature?: string;
+    sessionId?: string;
+}>;
+
+/**
+ * NEO-101: Register biometric data for an existing person
+ *
+ * This method registers facial biometric data for a person already in the system.
+ * It validates the image and sends it to the backend.
+ *
+ * @param personId The ID of the person to register biometric data for
+ * @param faceImage The face image blob to register
+ * @param applicationToken The application token for authentication
+ * @returns Promise with registration result
+ * @throws NeoFaceError if request fails
+ * @throws NeoFaceError if validation fails
+ */
+export declare const registerBiometric: (personId: string, faceImage: Blob, applicationToken: string) => Promise<{
+    success: boolean;
+    message: string;
+    identity_data_id?: string;
+    type_of_identification?: string;
+    have_biometric_data?: boolean;
+    created_at?: string;
+}>;
+
+/**
+ * Options for registering a document by image capture
+ */
+export declare interface RegisterDocumentByImageOptions {
+    /** Pre-select document type, skipping the selection screen */
+    preSelectedDocument?: 'RG' | 'CNH' | 'CPF';
+    /** Use back camera for capture (default: true) */
+    useBackCamera?: boolean;
+}
+
+/**
+ * Result of a document registration request
+ */
+export declare interface RegisterDocumentResult {
+    success: boolean;
+    taskId: string;
+    status: string;
+    message: string;
+}
+
+/**
+ * Register a person with face biometric data and liveness detection
+ * @param personData Person registration data
+ * @param facePhotos Array of face photos for biometric registration (up to 5 photos)
+ * @param applicationToken The application token for authentication
+ * @param options Optional document images
+ * @returns Promise with registration result
+ */
+export declare const registerPersonWithBiometric: (personData: {
+    name: string;
+    birth_date: string;
+    cpf: string;
+    email: string;
+    password: string;
+    is_pep?: boolean;
+}, facePhotos: Blob[], applicationToken: string, options?: {
+    documentFront?: Blob;
+    documentBack?: Blob;
+    documentType?: string;
+}) => Promise<{
+    success: boolean;
+    message: string;
+    person_id?: string;
+    user_id?: string;
+    person_validated?: boolean;
+    face_processing?: any;
+    onboarding_link?: string;
+    task_id?: string;
+    status?: string;
+}>;
+
+/**
+ * Register a person without face biometric data
+ * @param personData Person registration data
+ * @param applicationToken The application token for authentication
+ * @param options Optional document images
+ * @returns Promise with registration result
+ */
+export declare const registerPersonWithoutFace: (personData: {
+    name: string;
+    birth_date: string;
+    cpf: string;
+    email: string;
+    password: string;
+    is_pep?: boolean;
+}, applicationToken: string, options?: {
+    documentFront?: Blob;
+    documentBack?: Blob;
+    documentType?: string;
+}) => Promise<{
+    success: boolean;
+    message: string;
+    person_id?: string;
+    user_id?: string;
+    person_validated?: boolean;
+    onboarding_link?: string;
+    data?: any;
+}>;
+
+/**
+ * Data de lançamento da versão atual
+ */
+export declare const RELEASE_DATE = "2026-08-29";
+
+/**
+ * Exibe o modal de consentimento e resolve `true` se o titular aceitou,
+ * `false` se recusou. Deve ser chamado antes de qualquer `getUserMedia()`.
+ */
+export declare function requestConsent(info?: Partial<ConsentInfo>): Promise<boolean>;
+
+/**
+ * Request a password reset for a user account
+ * @param email User email address
+ * @param applicationToken Application token
+ */
+export declare function requestPasswordReset(email: string, applicationToken: string): Promise<{
+    message: string;
+}>;
+
+/**
+ * Configuração interna do SDK
+ */
+declare interface SDKConfig {
+    baseUrl: string;
+    applicationToken: string | null;
+    environment: Environment | 'custom';
+    initialized: boolean;
+}
+
+/**
+ * Opções de inicialização do SDK
+ */
+export declare interface SDKInitOptions {
+    /**
+     * Ambiente da aplicação. Se fornecido, a URL base será determinada automaticamente.
+     * Pode ser 'development', 'sandbox' ou 'production'.
+     */
+    environment?: Environment;
+    /**
+     * URL base da API. Se fornecido, tem precedência sobre 'environment'.
+     * Útil para ambientes customizados ou testes.
+     */
+    baseUrl?: string;
+    /**
+     * Token de aplicação para autenticação com a API.
+     * Obtido através do painel administrativo do NeoFaceID.
+     */
+    applicationToken?: string;
+}
+
+/**
+ * Session data interface for external integrations
+ */
+export declare interface SessionData {
+    email: string;
+    cpf: string;
+    sessionId: string;
+}
+
+/**
+ * Performs simple identification using document data
+ * @param documentType Type of document (e.g., 'CPF')
+ * @param documentNumber Document number
+ * @param applicationToken The application token for authentication
+ * @param purpose Purpose of identification (default: 'LOGIN')
+ * @returns Promise with identification result
+ * @throws NeoFaceError if request fails
+ */
+export declare const simpleIdentification: (documentType: string, documentNumber: string, applicationToken: string, purpose?: string) => Promise<{
+    success: boolean;
+    personId?: string;
+    accessToken?: string;
+    payload?: {
+        name: string;
+        email: string;
+        documentId: string;
+    };
+}>;
+
+export declare function start(applicationToken: string, callbacks: Callbacks): void;
+
+/**
+ * Inicia o processo de login com detecção automática do tipo biométrico
+ * @param options Opções de configuração para o login automático
+ */
+export declare function startAutoLogin(options: BiometricLoginOptions): Promise<void>;
+
+/**
+ * Start biometric registration process with liveness detection
+ * @param personData Person registration data (name, cpf, birth_date, email, password)
+ * @param applicationToken Application token for authentication
+ * @param callbacks Success and error callbacks
+ */
+export declare function startBiometricRegistration(personData: {
+    name: string;
+    birth_date: string;
+    cpf: string;
+    email: string;
+    password: string;
+}, applicationToken: string, callbacks: BiometricRegistrationCallbacks, options?: {
+    useRealApi?: boolean;
+}): void;
+
+/**
+ * Função auxiliar para iniciar a captura de documento
+ */
+export declare const startDocumentCapture: (options?: DocumentCaptureOptions) => Promise<DocumentCaptureResult>;
+
+/**
+ * Inicia o processo de login usando reconhecimento facial
+ * Usa overlay minimalista estilo FaceID (não mostra câmera)
+ * @param options Opções de configuração para o login facial
+ */
+export declare function startFaceLogin(options: BiometricLoginOptions): Promise<void>;
+
+/**
+ * Inicia o processo de login usando reconhecimento de mão
+ * @param options Opções de configuração para o login por mão
+ */
+export declare function startHandLogin(options: BiometricLoginOptions): Promise<void>;
+
+/**
+ * Start liveness capture process only (no registration)
+ * @param applicationToken Application token for authentication
+ * @param callbacks Success and error callbacks
+ */
+export declare function startLivenessCapture(applicationToken: string, callbacks: {
+    onSuccess(photos: Blob[]): void;
+    onError(code: string, message: string): void;
+    onCancel?(): void;
+}): void;
+
+/**
+ * Inicia o fluxo de onboarding: valida token, captura face e documento, conclui no backend.
+ * Este método orquestra o processo completo e expõe callbacks de sucesso/erro.
+ */
+export declare const startOnboarding: (options: StartOnboardingOptions) => Promise<void>;
+
+export declare interface StartOnboardingOptions {
+    applicationToken: string;
+    onboardingToken: string;
+    countdown?: number;
+    title?: string;
+    subtitle?: string;
+    onSuccess: (result: {
+        success: boolean;
+        message: string;
+        person_id?: string;
+        identity_data_id?: string;
+        confidence_score?: number;
+        processing_time?: number;
+        details: OnboardingLinkDetails;
+    }) => void;
+    onError: (error: NeoFaceError) => void;
+    onCancel?: () => void;
+}
+
+/**
+ * Result of user existence check
+ */
+declare interface UserExistenceResult {
+    success: boolean;
+    message: string;
+    data: {
+        exists: boolean;
+    };
+}
+
+/**
+ * Valida se um token de onboarding é válido
+ * @param applicationToken Token da aplicação (header `X-App-Token`)
+ * @param onboardingToken Token do link de onboarding a ser validado
+ * @returns Promise que resolve para true se o token é válido, false caso contrário
+ * @throws NeoFaceError em caso de falha de rede ou autorização
+ */
+export declare const validateOnboardingToken: (applicationToken: string, onboardingToken: string) => Promise<boolean>;
+
+/**
+ * Validates an application token
+ * @param applicationToken The application token to validate
+ * @returns Promise that resolves to true if token is valid, false otherwise
+ * @throws NeoFaceError if request fails
+ */
+export declare const validateToken: (applicationToken: string) => Promise<boolean>;
+
+/**
+ * Versão atual do SDK NeoFace ID Web
+ * Formato: MAJOR.MINOR.PATCH
+ *
+ * MAJOR: Incrementado quando há mudanças incompatíveis com versões anteriores
+ * MINOR: Incrementado quando adicionamos funcionalidades mantendo compatibilidade
+ * PATCH: Incrementado quando corrigimos bugs mantendo compatibilidade
+ */
+export declare const VERSION = "1.25.5";
+
+export { }