import { default as default_2 } from 'react';
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 type AuthMethod = z.infer<typeof AuthMethodSchema>;

/**
 * Por qual caminho a pessoa se autenticou.
 *
 * O console trata `password` como caminho degradado — entra, mas não executa
 * operação de risco alto. Sem este campo o host não tem como distinguir, já que
 * o resultado dos dois caminhos tem exatamente a mesma forma.
 */
declare const AuthMethodSchema: z.ZodEnum<{
    face: "face";
    password: "password";
}>;

export declare interface AuthorizationOptions {
    onProgress?: (step: number, totalSteps: number, instruction: string) => void;
    onPhotoTaken?: (photoNumber: number, blob: Blob) => void;
    captureDelay?: number;
    /** Nome do integrador exibido no topo do modal de consentimento (US14.2). */
    appName?: string;
}

export declare interface AuthorizationResult {
    success: boolean;
    authorizationHash?: string;
    name?: string;
    birthDate?: string;
    cpf?: string;
    confidenceScore?: number;
    message?: string;
}

/**
 * authorize — autoriza uma operação por biometria, orquestrando
 * consent + captura + desafio de vivacidade (via runLivenessChallenge, NEO-408).
 *
 * O servidor sorteia a sequência de gestos, valida cada frame enviado e decide
 * o resultado. O SDK apenas exibe e coleta ("client collects, server decides").
 */
export declare function authorize(options: AuthorizeOptions): Promise<void>;

/**
 * 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 interface AuthorizeOptions {
    applicationToken: string;
    /** Titular sendo autorizado (CPF, e-mail ou id opaco). */
    subject: string;
    /** Nome do integrador (fallback: `init({ appName })`). */
    appName?: string;
    /**
     * Número máximo de desafios (0-3). O servidor decide a sequência (NEO-408
     * runLivenessChallenge) — este campo é apenas um teto sugerido ao backend.
     */
    challenges?: 0 | 1 | 2 | 3;
    /** Valor monetário exibido no header. Ex.: 1250 = "R$ 1.250,00". */
    amount?: number;
    onChallengeStart?: (gesture: ChallengeGesture, index: number, total: number) => void;
    onChallengeComplete?: (gesture: ChallengeGesture, index: number, total: number) => void;
    /**
     * NEO-427: agora recebe o resultado da COLETA (sessionId + challenge + gestures
     * capturadas). O SDK não decide aprovação — envie os frames via seu próprio
     * pipeline de recognition (ex.: `POST /auth/recognition/face/`).
     */
    onSuccess?: (result: RunLivenessChallengeCollectResult) => void;
    onError?: (error: NeoFaceError) => void;
    onCancel?: () => void;
    /**
     * NEO-420 · US14.9 — "screen flash" assistivo: quando o frame está muito
     * escuro, inverte o fundo para branco alto brilho para usar a tela como
     * fonte de luz. Só ajuda quando faz diferença: se não subir o brilho,
     * reverte. Nunca usado como sinal de liveness (essa decisão é do servidor).
     * Default: `true`.
     */
    autoLighting?: boolean;
}

/** Ver {@link SDKInitOptions.autoFallback}. */
export declare interface AutoFallbackOptions {
    /**
     * Nível 1 — oferecer confirmação no celular quando o dispositivo atual não
     * dá conta (sem câmera, permissão negada) ou quando o purpose exige.
     *
     * Default `false`. Quem decide se há aparelho é o core, na resposta: o SDK
     * não consegue (e não deve) descobrir isso sozinho — um endpoint que
     * respondesse "esta pessoa tem aparelho?" autenticado por `X-App-Token`,
     * que é público por desenho, seria um oráculo de enumeração.
     */
    toPhone?: boolean;
    /**
     * Nível 2 — abrir o modal de e-mail e senha.
     *
     * Default `true`, que é o comportamento histórico de `startFaceLogin`
     * quando `onFallbackRequest` não é passado. Mudá-lo para `false` por padrão
     * quebraria todo integrador publicado, então a mudança fica explícita.
     */
    toPassword?: boolean;
}

/**
 * Abre a tela "Confirme no seu celular" e aguarda a decisão pelo SSE do core.
 *
 * Este primitivo é avulso de propósito. Desde a NEO-427 o `authorize()` só
 * **coleta** — quem submete ao core é o host, então é o host que recebe a
 * resposta "exige confirmação no celular" e chama esta função com o
 * `requestId` que veio de lá.
 *
 * O SDK nunca fala com a plataforma Push: o canal é sempre o core.
 *
 * @example
 * ```ts
 * const r = await meuBackend.submeter(frames);
 * if (r.requires_push) {
 *   const outcome = await awaitPushApproval({
 *     requestId: r.request_id,
 *     applicationToken: TOKEN,
 *     expiresIn: r.expires_in,
 *     numericCode: r.numeric_code,
 *   });
 *   if (outcome.status === 'approved') continuar();
 *   else if (outcome.status === 'expired') caiParaSenha();
 *   // 'denied' é terminal — não oferece caminho alternativo.
 * }
 * ```
 */
export declare function awaitPushApproval(options: AwaitPushApprovalOptions): Promise<PushApprovalOutcome>;

export declare interface AwaitPushApprovalOptions {
    /**
     * Identificador da solicitação, devolvido pelo core na resposta que exigiu
     * confirmação no celular.
     */
    requestId: string;
    applicationToken: string;
    /** Prazo informado pelo core, em segundos. */
    expiresIn: number;
    /**
     * Código de correspondência numérica de 2 dígitos, quando a política exigir.
     * O SDK apenas **exibe**; conferir é papel do celular contra o servidor.
     */
    numericCode?: string;
    /** Nome do integrador (fallback: `init({ appName })`). */
    appName?: string;
    /** Oferece "entrar de outro jeito" na tela de expiração. */
    onFallback?: () => void;
}

export declare class BiometricCaptureModal {
    private modal;
    private video;
    private canvas;
    private stream;
    private options;
    private countdownInterval;
    private isCapturing;
    private flashController;
    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;
    /**
     * NEO-413 · US14.6 (item 18) — a contagem "3, 2, 1" foi removida.
     * Agora habilita direto o botão "Capturar" assim que a câmera fica pronta.
     * Vivacidade fica com o desafio `runLivenessChallenge` (NEO-408), servidor decide.
     */
    private enableCaptureButton;
    /**
     * 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;
}

export declare interface BiometricCaptureOptions {
    mode: 'face' | 'hand' | 'auto';
    /** NEO-228 · `environmentPayload` carrega os sinais de ambiente coletados ainda com a câmera ativa — anexar ao request biométrico que o consumer dispara a partir daqui. */
    onSuccess: (imageData: string, detectedType: 'face' | 'hand', environmentPayload: EnvironmentPayload) => void;
    onError: (error: NeoFaceError) => void;
    onCancel?: () => void;
    countdown?: number;
    title?: string;
    subtitle?: string;
    /** NEO-425 · US14.11.a — screen flash assistivo em ambiente escuro. Default true. */
    autoLighting?: boolean;
}

export declare interface BiometricLoginOptions {
    applicationToken: string;
    /**
     * Nome do integrador exibido no topo do modal de consentimento (US14.2).
     * Ausência gera console.warn e cai para o fallback "sua aplicação".
     */
    appName?: string;
    onSuccess: (result: BiometricLoginResult) => void;
    /**
     * Chamado quando o fluxo guiado **termina** — ou seja, quando o usuário
     * cancela, escolhe entrar por email/senha, ou ocorre um erro fora do loop
     * de tentativas (ex.: `CONSENT_DENIED` antes da câmera abrir).
     *
     * Nas falhas de reconhecimento que acontecem **dentro** do loop de
     * tentativas (401, 429, rosto não detectado, etc.), o SDK exibe o
     * `FallbackPrompt` internamente antes de propagar ao host. Use
     * `onAttemptError` para ser notificado dessas falhas individuais.
     */
    onError: (error: NeoFaceError) => void;
    /**
     * NEO-563 — Chamado a cada tentativa de login que falha, **antes** de o
     * `FallbackPrompt` aparecer. Permite ao integrador registrar falhas
     * individuais no próprio sistema de monitoramento.
     *
     * @param error  O erro da tentativa que falhou.
     * @param attempt Número da tentativa (começa em 1).
     *
     * @example
     * ```ts
     * startFaceLogin({
     *   applicationToken,
     *   onSuccess: r => console.log('ok', r),
     *   onError: err => console.error('fluxo encerrado', err),
     *   onAttemptError: (err, attempt) =>
     *     analytics.track('biometric_attempt_failed', { attempt, type: err.type }),
     * });
     * ```
     */
    onAttemptError?: (error: NeoFaceError, attempt: number) => 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>;
    refreshToken: z.ZodOptional<z.ZodString>;
    method: z.ZodOptional<z.ZodEnum<{
        face: "face";
        password: "password";
    }>>;
    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>;

declare interface BiometricRegistrationCallbacks {
    onSuccess(result: BiometricRegistrationResult): void;
    onError(err: NeoFaceError): void;
}

export declare function BiometricRegistrationModal({ personData, applicationToken, onClose, onSuccess, onPhotosCaptured, onError, onCannotGesture, autoLighting, voiceGuidance, onEvent, }: BiometricRegistrationModalProps): JSX_2.Element;

declare interface BiometricRegistrationModalProps {
    personData?: {
        name: string;
        birth_date: string;
        cpf: string;
        email: string;
        password: string;
        /** NEO-579 · Fix 8 — telefone da pessoa (opcional) */
        phone?: string;
    };
    applicationToken?: string;
    onClose: () => void;
    onSuccess?: (result: BiometricRegistrationResult_2) => void;
    onPhotosCaptured?: (photos: Blob[]) => void;
    /**
     * NEO-579 · Fix 7 — `type` carrega o código real do erro (ex.: `CAPTURE_ERROR`)
     * em vez de sempre cair em `UNKNOWN` no consumidor do SDK.
     */
    onError: (error: string, type?: ErrorType) => void;
    useRealApi?: boolean;
    /**
     * NEO-579 · Fix 7 — gancho de rastreabilidade, sem PII nem imagens.
     * Disparado nos principais eventos do ciclo de captura.
     */
    onEvent?: (event: CaptureEvent) => void;
    /**
     * NEO-579 · Fix 5 — guia de voz via speechSynthesis.
     * Padrão: `true` em dispositivos móveis, `false` em desktop.
     * Pode ser forçado explicitamente pelo integrador.
     */
    voiceGuidance?: boolean;
    /**
     * NEO-410 · US14.3 — callback disparado pelo botão "Não consigo fazer esse movimento",
     * visível desde o PRIMEIRO desafio. O consumidor decide o que fazer (abrir fallback
     * próprio, pedir vivacidade passiva ao backend, cair para email/senha). Se ausente,
     * o clique fecha o modal via `onClose`.
     */
    onCannotGesture?: () => void;
    /**
     * NEO-425 · US14.11.a — "screen flash" assistivo: se o ambiente está escuro,
     * o SDK inverte o fundo do modal para branco alto brilho. Default `true`.
     */
    autoLighting?: 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
 * @deprecated Utilize o componente CameraOvalGuide (showCameraOvalGuideModal) para preview de câmera com guia oval.
 */
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(err: NeoFaceError): void;
}

export declare type CameraMobileHandoffOutcome = {
    status: 'dismissed';
} | {
    status: 'expired';
} | {
    status: 'already_used';
};

/**
 * Componente de guia oval para captura facial.
 *
 * Renderiza o preview da câmera com um oval SVG sobreposto e um halo colorido
 * que indica o estado de posicionamento do rosto em tempo real.
 *
 * @example
 * ```tsx
 * <CameraOvalGuide
 *   stream={mediaStream}
 *   faceState="centered"
 *   instruction="Mantenha o rosto no oval"
 * />
 * ```
 */
export declare function CameraOvalGuide({ stream, faceState, instruction, className, style, }: CameraOvalGuideProps): JSX_2.Element;

/**
 * Props do componente CameraOvalGuide.
 */
export declare interface CameraOvalGuideProps {
    /** Stream de vídeo da câmera. Null enquanto aguarda permissão. */
    stream: MediaStream | null;
    /** Estado de posicionamento do rosto — controla a cor do halo. */
    faceState: FaceState;
    /** Instrução textual exibida abaixo do oval (ex: "Aproxime o rosto"). */
    instruction: string;
    /** Classe CSS adicional aplicada ao container externo. */
    className?: string;
    /** Estilos inline adicionais aplicados ao container externo. */
    style?: default_2.CSSProperties;
}

export declare interface CaptureEvent {
    type: CaptureEventType;
    /** Timestamp ISO 8601 */
    timestamp: string;
    /** Dados complementares sem PII */
    data?: Record<string, string | number | boolean>;
}

/** Eventos de captura emitidos via `onEvent`. Sem PII, sem imagens. */
export declare type CaptureEventType = 'camera_opened' | 'camera_error' | 'models_loaded' | 'models_error' | 'challenge_started' | 'challenge_completed' | 'challenge_timeout' | 'capture_success' | 'capture_error';

/**
 * Captura quadros do rosto sem abrir modal.
 *
 * Substitui `new NeoFaceID(...).captureFaceFrames(options)`, removido na 2.0.0.
 * Não precisava da instância — só a mantinha por estar pendurado na classe.
 */
export declare function captureFaceFrames(options: CaptureFaceFramesOptions): Promise<Blob[]>;

/** Opções de {@link captureFaceFrames}. */
export declare interface CaptureFaceFramesOptions {
    /** Quantos quadros capturar, de 1 a 10. */
    numFrames: number;
    /**
     * Espaça as capturas em 300 ms. Uma foto estática produz quadros idênticos;
     * um rosto presente, não.
     */
    livenessCheck: boolean;
}

/**
 * NEO-228 · Coleta sinais do ambiente de captura (câmera virtual, variância de
 * canvas, resolução, fps) para REPORTAR ao servidor. O SDK nunca decide nada
 * com base nesses sinais — quem pondera é o backend (NEO-262). Ver regra
 * [project-client-collects-server-decides] e o contrato em
 * docs/environment-signals-contract.md (fechado em NEO-285/US8.10).
 */
declare type CaptureMode = 'sdk' | 'fallback';

/**
 * Purpose aceito por `POST /api/v1/auth/capture/session/`. O backend valida
 * contra o mesmo `Purpose` enum, mas a API pública do SDK usa minúsculas
 * (o valor é maiusculizado antes do envio — ver `captureSession.ts`).
 */
export declare type CapturePurpose = Lowercase<RecognitionPurpose>;

export declare interface CaptureSession {
    session_id: string;
    expires_at: string;
}

export declare interface ChallengeGesture {
    index: number;
    gesture_key: GestureKey | string;
    /**
     * Instrução pronta pelo backend (v1.4.x, respeita `Accept-Language`).
     * Nos payloads legados vinha via `instruction_i18n`.
     */
    instruction?: string;
    instruction_i18n?: Record<string, string>;
}

/**
 * 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>;

/**
 * Limpa o histórico de consentimentos no localStorage.
 */
export declare function clearConsentTrail(): void;

/**
 * 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;
}>;

/**
 * Dados de consentimento LGPD informados pelo integrador.
 * Usados pelo SDK para registrar a base legal da coleta biométrica.
 */
export declare interface Consent {
    /** Finalidade da coleta (ex: 'authentication', 'onboarding'). */
    purpose: string;
    /**
     * Base legal. Legítimo interesse não é permitido para dado sensível (LGPD art. 11).
     * Valores: 'consent' | 'legal_obligation' | 'fraud_prevention'.
     */
    legalBasis: 'consent' | 'legal_obligation' | 'fraud_prevention';
    /** URL da política de privacidade apresentada ao titular. */
    privacyPolicyUrl: string;
    /** Prazo de retenção em dias (0 = indefinido/não informado). */
    retentionDays: number;
}

declare type ConsentFlow = 'verification' | 'registration';

export declare interface ConsentInfo {
    appName?: string;
    flow?: ConsentFlow;
    privacyPolicyUrl?: string;
    retentionDays?: number;
}

export declare class ConsentModal {
    private container;
    private root;
    show(props: ConsentModalProps): void;
    close(): void;
}

export declare interface ConsentModalProps {
    appName: string;
    flow: ConsentFlow;
    privacyPolicyUrl?: string;
    retentionDays?: number;
    onAccept: () => void;
    onDecline: () => void;
}

export declare interface ConsentRecord {
    hash: string;
    timestamp: string;
    purpose: string;
    legalBasis: string;
    sdkVersion: string;
}

export declare interface ConsumeSseOptions<T> {
    /**
     * Pede um ticket ao core. Chamado na abertura **e a cada reconexão** — o
     * ticket é de uso único e expira em 60 s (`core/sse_access.py`), então
     * reconectar com o mesmo valor sempre falharia na autenticação.
     */
    requestTicket: () => Promise<string>;
    /** Monta a URL do EventSource a partir de um ticket recém-emitido. */
    buildUrl: (ticket: string) => string;
    /** Decide, frame a frame, se o fluxo terminou. */
    classify: (frame: SseFrame) => SseVerdict<T>;
    /** Teto absoluto do fluxo. Default 310 s (o core faz timeout em 300 s). */
    timeoutMs?: number;
    /** Máximo de reconexões antes de desistir. Default 5. */
    maxReconnects?: number;
    /** Cancela o fluxo de fora (ex.: usuário fechou o modal). */
    signal?: AbortSignal;
    /** Injeção para teste. Default: `globalThis.EventSource`. */
    eventSourceFactory?: (url: string) => EventSource;
    /** Notifica cada frame não-terminal (ex.: atualizar UI). */
    onProgress?: (frame: SseFrame) => void;
}

/**
 * Consome um stream SSE do core até um veredito terminal.
 *
 * Diferenças em relação ao consumidor antigo (`loginWithBiometricSSE`, que era
 * código morto e nunca funcionou):
 *
 * 1. escuta o evento default `message`, que é o que o core de fato emite;
 * 2. reconecta pedindo **ticket novo**, em vez de rejeitar no primeiro soluço
 *    de rede — o comentário em `api.ts` prometia isso e o código não fazia;
 * 3. distingue o fechamento normal do servidor (que acontece logo após um
 *    status terminal) de uma queda de conexão de verdade.
 */
export declare function consumeSseStream<T>(options: ConsumeSseOptions<T>): Promise<T>;

/**
 * Compatibilidade com callers antigos que passavam `{ purpose, legalBasis }`.
 * Deprecated — remover quando US14.4 unificar tokens.
 */
export declare const DEFAULT_CONSENT_INFO: ConsentInfo;

/** Desfecho da inscrição de aparelho. */
export declare type DeviceEnrollmentOutcome = {
    status: 'enrolled';
    deviceLabel: string | null;
    enrolledAt?: string;
} | {
    status: 'expired';
} | {
    status: 'cancelled';
};

/** Token de inscrição de aparelho, devolvido por {@link requestDeviceEnrollmentToken}. */
export declare interface DeviceEnrollmentToken {
    /**
     * Identificador curto, no formato `XXXX-XXXX`, de um alfabeto sem os pares
     * que se confundem (`0/O`, `1/I/L`, `U/V`).
     *
     * **É isto que o QR deve carregar**, não o {@link token}. O JWT inteiro vira
     * uma grade densa que exige tela grande e câmera boa, e deixa o segredo
     * óptico — exposto em qualquer foto da tela. O handle fotografado vale muito
     * menos: não carrega `person_id`, `consumer_id` nem assinatura, e morre na
     * primeira troca. Como é legível, também serve para ditar por telefone ou
     * digitar à mão quando a câmera falha.
     */
    handle: string;
    /**
     * Identificador da solicitação. É a chave do canal SSE que avisa quando o
     * aparelho for inscrito: `/api/v1/devices/enrollment/{jti}/events/`.
     */
    jti: string;
    /**
     * JWT RS256 de uso único. Continua vindo por compatibilidade, mas **não deve
     * ir para o QR** — quem resolve o handle é o Push, contra o core, por canal
     * interno.
     */
    token: string;
    /** Validade em segundos (o core emite 300). */
    expiresIn: number;
    purpose: string;
}

export declare class DocumentCaptureModal {
    private overlay;
    private video;
    private canvas;
    private stream;
    private resolvePromise;
    private options;
    private selectedDocument;
    private currentStep;
    private flashController;
    private frontBlob;
    private backBlob;
    private _previewObjectUrl;
    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 startScreenFlash;
    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;
    /** Nome do integrador exibido no topo do modal de consentimento (US14.2). */
    appName?: string;
    /* Excluded from this release type: skipConsent */
    /** NEO-425 · US14.11.a — screen flash assistivo em ambiente escuro. Default true. */
    autoLighting?: boolean;
}

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;
}

export declare type Environment = 'development' | 'sandbox' | 'production';

/**
 * Mapeamento de ambientes para URLs base da API
 */
export declare const ENVIRONMENT_URLS: Record<Environment, string>;

declare interface EnvironmentPayload {
    env_contract_version: number;
    environment?: EnvironmentSignals;
    signals_error: boolean;
}

declare interface EnvironmentSignals {
    device_label: string;
    device_id_hash: string;
    virtual_camera_suspected: boolean;
    virtual_camera_signals: string[];
    resolution: {
        w: number;
        h: number;
    };
    framerate_effective: number;
    capture_mode: CaptureMode;
    sdk_version: 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",
    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",
    /** NEO-224 · piscada real (EAR) não detectada dentro da janela de liveness. */
    LIVENESS_BLINK_MISSING = "LivenessBlinkMissingError",
    /** NEO-230 · polegar para cima não detectado na janela de authorizeOperation. */
    GESTURE_NOT_DETECTED = "GestureNotDetectedError",
    /** NEO-239 · 429 ou `X-RateLimit-Remaining: 0` — ver `retryAfterMs` em `NeoFaceError`. */
    RATE_LIMITED = "RateLimitedError"
}

export declare function FaceCaptureModal({ accessToken, onClose, onSuccess, onCannotGesture, autoLighting, }: FaceCaptureModalProps): JSX_2.Element;

declare interface FaceCaptureModalProps {
    accessToken: string;
    onClose: () => void;
    onSuccess: (result: RecognitionResult) => void;
    /**
     * NEO-410 · US14.3 — callback do botão "Não consigo fazer esse movimento",
     * visível desde o PRIMEIRO desafio. Ausente = clique fecha o modal.
     */
    onCannotGesture?: () => void;
    /**
     * NEO-425 · US14.11.a — "screen flash" assistivo em ambiente escuro. Default true.
     */
    autoLighting?: boolean;
}

/**
 * Purpose aceito pelo corpo de `POST /api/v1/auth/recognition/face/`
 * (`FaceRecognitionRequestSchemaPurposeEnum` no schema.yml) — os mesmos 11
 * valores, exceto `AGE_ESTIMATION` e `FACE_COMPARISON`, que não fazem parte
 * desse endpoint.
 */
export declare type FaceRecognitionPurpose = Exclude<RecognitionPurpose, 'AGE_ESTIMATION' | 'FACE_COMPARISON'>;

/**
 * Estado de posicionamento do rosto detectado.
 * - `searching` — nenhum rosto detectado ainda
 * - `too-far` — rosto muito distante da câmera
 * - `too-close` — rosto muito próximo da câmera
 * - `off-center` — rosto fora do centro do oval
 * - `centered` — rosto corretamente posicionado
 */
export declare type FaceState = 'searching' | 'too-far' | 'too-close' | 'off-center' | 'centered';

/**
 * 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;
}

/**
 * Chaves de gesto reconhecidas pelo backend real (case-insensitive; SDK
 * normaliza para maiúsculo). Novos gestos podem aparecer sem impacto no SDK
 * — o campo é `string` na runtime.
 */
export declare type GestureKey = 'LOOK_LEFT' | 'LOOK_RIGHT' | 'LOOK_UP' | 'LOOK_DOWN' | 'BLINK' | 'SMILE' | 'OPEN_MOUTH' | 'turn_left' | 'turn_right' | 'look_up' | 'look_down' | 'blink' | 'smile' | 'open_mouth';

export declare interface GestureResponse {
    gesture_key: string;
    /** Frames capturados como data URL ou base64. SDK só empacota — servidor valida. */
    images: string[];
}

/** Retorna a cor de acento configurada, se houver (antes do validador de contraste). */
export declare function getAccent(): string | null;

/**
 * Retorna o token de aplicação configurado, se houver.
 */
export declare function getApplicationToken(): string | null;

/** Retorna o nome do integrador configurado, se houver. */
export declare function getAppName(): string | null;

/** Retorna a política de quedas automáticas de canal. Ver {@link AutoFallbackOptions}. */
export declare function getAutoFallback(): Required<AutoFallbackOptions>;

/**
 * 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;

export declare function getCachedCaptureSession(): CaptureSession | null;

/**
 * Retorna toda a configuração atual (para debug).
 */
export declare function getConfig(): Readonly<SDKConfig>;

/** Retorna os dados de consentimento configurados (ou os defaults conservadores). */
export declare function getConsent(): Consent;

/**
 * Retorna o histórico (trail) de consentimentos gravados no localStorage.
 * Falha silenciosamente retornando array vazio caso o localStorage esteja inacessível.
 */
export declare function getConsentTrail(): ConsentRecord[];

/**
 * Retorna o ambiente atual configurado.
 */
export declare function getEnvironment(): Environment | 'custom';

/** Retorna o locale configurado (padrão 'pt-BR'). */
export declare function getLocale(): string;

/** Retorna o raio base configurado (padrão 16). */
export declare function getRadius(): SDKRadius;

/**
 * Retorna o modo de tema resolvido para a superfície de UI (light | dark).
 * Considera 'auto' + `prefers-color-scheme`. Útil para consumidores que
 * precisam alinhar visualmente algum elemento próprio ao SDK.
 */
export declare function getResolvedThemeMode(): ThemeMode;

/** Retorna o modo de tema configurado (padrão 'light'). */
export declare function getTheme(): SDKTheme;

export declare function HandoffAlreadyUsedView({ onRetry, onCancel, }: HandoffAlreadyUsedViewProps): JSX.Element;

declare interface HandoffAlreadyUsedViewProps {
    onRetry: () => void;
    onCancel: () => void;
}

export declare function HandoffExpiredView({ onRetry, onCancel }: HandoffExpiredViewProps): JSX.Element;

/**
 * NEO-456 · Tela de handoff para celular quando a câmera falha no onboarding.
 *
 * Exibe um QR (handle curto, nunca credencial) + link clicável ao lado para
 * quem já está no celular, um cronômetro visual e as telas de expirado/já-usado.
 *
 * ⚠️  AGUARDA NEO-545 — o endpoint que emite o handle ainda não existe.
 *     Ver requestOnboardingMobileHandoff() em api.ts.
 */
declare interface HandoffExpiredViewProps {
    onRetry: () => void;
    onCancel: () => void;
}

/**
 * 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;

/**
 * Verifica se o SDK foi inicializado.
 */
export declare function isInitialized(): boolean;

export declare interface LivenessChallenge {
    /**
     * ID do desafio. **Opcional no contrato v1.4.x** — o backend real rastreia
     * o desafio pelo `session_id` e não devolve `challenge_id` no payload.
     * Mantido opcional para consumidores que ainda dependem do valor.
     */
    challenge_id?: string;
    gestures: ChallengeGesture[];
    /** Data ISO derivada de `expires_in` (segundos) ou legado `expires_at`. */
    expires_at?: string;
    /** Segundos até expirar (contrato v1.4.x). */
    expires_in?: number;
    language?: string;
}

export declare interface LivenessChallengeResult {
    success: boolean;
    liveness_passed?: boolean;
    score?: number;
    raw: unknown;
}

/**
 * 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, 
/** NEO-228 · sinais de ambiente — opcional para não quebrar chamadas existentes do consumer. */
environmentPayload?: EnvironmentPayload) => 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;
    /**
     * NEO-562 · Presente quando o erro veio de um HTTP 429 (rate limit) — tempo
     * em ms sugerido pelo `Retry-After` da API antes de uma nova tentativa.
     */
    retryAfterMs?: number;
    /**
     * 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;
}

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;
}

/**
 * Resposta do endpoint de mobile-handoff de onboarding.
 *
 * @remarks
 * ⚠️  AGUARDA NEO-545 — o backend ainda não implementou este endpoint.
 *     O contrato abaixo foi acordado com o time de backend em 21/09 e reflete
 *     a spec do cartão NEO-545. Quando o endpoint for mergeado, validar:
 *       - A URL exata (`/api/v1/onboardings/{token}/mobile-handoff/`)
 *       - O nome exato dos campos (`handle`, `portal_url`, `expires_in`)
 *       - O formato do handle (esperado `XXXX-XXXX`, igual ao de device-enrollment)
 *     Remover este aviso após a integração.
 */
export declare interface OnboardingMobileHandoff {
    /**
     * Identificador curto, opaco, de uso único — é **isto** que o QR carrega.
     * Mesmo formato do handle de device-enrollment (`XXXX-XXXX`): sem 0/O, 1/I/L, U/V.
     * Nunca expõe o `onboardingToken` nem qualquer credencial na URL do QR.
     */
    handle: string;
    /**
     * URL do portal para onde o celular deve navegar ao ler o QR.
     * Vem da API (por aplicação) — nunca derivada de hostname ou variável de build.
     * Exemplos: `https://app.neofaceid.com` ou `https://sandbox.neofaceid.com`.
     */
    portalUrl: string;
    /** Validade do handle em segundos (esperado ≈ 300 s = 5 min). */
    expiresIn: number;
}

/**
 * Interface para dados da pessoa no onboarding
 */
export declare interface OnboardingPersonData {
    name?: string;
    birth_date?: string;
    cpf?: string;
    cnpj?: string;
    email?: string;
}

/**
 * Abre uma sessão de captura no servidor. Server-decides: o `session_id`
 * vem do backend, nunca é inventado no cliente.
 *
 * @throws NeoFaceError em 4xx/5xx ou payload inválido.
 */
export declare function openCaptureSession({ applicationToken, purpose, }: OpenCaptureSessionParams): Promise<CaptureSession>;

export declare interface OpenCaptureSessionParams {
    applicationToken: string;
    purpose: CapturePurpose;
}

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 de detecção facial (chame no início da aplicação para
 * evitar o delay do primeiro `loadFromUri` durante a interação do usuário).
 *
 * Os modelos não são publicados no bundle do SDK — precisam ser auto-hospedados
 * pelo consumer em `/models/` (relativo à origem do app). Se os arquivos não
 * forem encontrados, um `console.error` acionável é emitido indicando o que
 * copiar e para onde.
 */
export declare function preloadFaceDetectionModels(): Promise<void>;

/**
 * Prova de vida: grava um vídeo curto da câmera, envia ao core e aguarda o
 * resultado da detecção de vivacidade e do reconhecimento.
 *
 * Substitui `new NeoFaceID({ appToken }).proofOfLife(options)`, removido na
 * 2.0.0. A migração é direta:
 *
 * ```ts
 * // antes
 * const sdk = new NeoFaceID({ appToken: TOKEN });
 * const r = await sdk.proofOfLife({ videoDurationMs: 3000 });
 *
 * // depois
 * const r = await proofOfLife({ applicationToken: TOKEN, videoDurationMs: 3000 });
 * ```
 *
 * `success: false` com `isLive: false` é desfecho, não exceção — a pessoa pode
 * simplesmente não ter passado na prova. Exceção fica para falha de câmera,
 * rede ou credencial.
 */
export declare function proofOfLife(options?: ProofOfLifeOptions): Promise<ProofOfLifeResult>;

/** Opções de {@link proofOfLife}. */
export declare interface ProofOfLifeOptions {
    /**
     * Token da aplicação. Se omitido, usa o informado em `init({ applicationToken })`.
     */
    applicationToken?: string;
    /** Duração da gravação, em milissegundos. Default 3000. */
    videoDurationMs?: number;
    /** Máximo de consultas ao status da task. Default 60. */
    maxPollingAttempts?: number;
    /** Intervalo entre consultas, em milissegundos. Default 1000. */
    pollingIntervalMs?: number;
    /** Progresso da gravação, de 0 a 100. */
    onRecordingProgress?: (progress: number) => void;
    /** Mudança de estado da task no core. */
    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;
}

/**
 * Desfecho da confirmação no celular.
 *
 * `denied` e `expired` são desfechos, não exceções — quem chama precisa
 * distinguir os dois para dirigir a cascata de fallback: expirar pode cair
 * para senha, recusar **não pode**.
 *
 * `cancelled` carrega `source` pelo mesmo motivo: a pessoa fechar o modal no
 * navegador e a solicitação ser cancelada do outro lado são situações
 * diferentes, e dizer "você cancelou" para quem não cancelou é afirmar algo
 * falso. É o colapso que o core pediu para evitar entre `denied` e `expired`,
 * um nível abaixo.
 */
export declare type PushApprovalOutcome = {
    status: 'approved';
    data: Record<string, unknown>;
} | {
    status: 'denied';
    reason?: string;
} | {
    status: 'expired';
} | {
    status: 'cancelled';
    source: 'user' | 'server';
    reason?: string;
};

/**
 * Vocabulário canônico de `purpose` aceito pela API NeoFaceID.
 *
 * Fonte: `core/enums.py` (`Purpose`) no backend, conferido na auditoria da
 * NEO-479 (14/10/2026) — 11 valores, incluindo `AGE_ESTIMATION` (NEO-392).
 * Esta é a ÚNICA lista que deve existir no SDK: todo outro tipo de purpose
 * (vocabulário em minúsculas da sessão de captura, subconjunto do corpo de
 * reconhecimento) é derivado dela, nunca redigitado.
 *
 * Mudou no backend? Atualize só aqui — `CapturePurpose` e
 * `FaceRecognitionPurpose` acompanham automaticamente.
 */
declare const RECOGNITION_PURPOSES: readonly ["AGE_ESTIMATION", "AUTHORIZATION", "FACE_COMPARISON", "KYB", "KYC", "LOGIN", "ONBOARDING", "PROOF_OF_LIFE", "SIMPLE_IDENTIFICATION_F", "SIMPLE_IDENTIFICATION_V", "SIMPLIFIED_REGISTRATION"];

/** União dos 11 valores de `PurposeEnum` (schema.yml). */
export declare type RecognitionPurpose = (typeof RECOGNITION_PURPOSES)[number];

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 — ver {@link FaceRecognitionPurpose} (NEO-479: union
 *   gerada a partir do `PurposeEnum` real da API, não mais uma lista digitada à mão)
 * @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: FaceRecognitionPurpose, confidenceThreshold?: number, signature?: string, sessionData?: SessionData, 
/** NEO-228 · sinais de ambiente — opcional para não quebrar chamadas existentes do consumer. */
environmentPayload?: EnvironmentPayload) => Promise<{
    success: boolean;
    personName?: string;
    email?: string;
    cpf?: string;
    confidenceScore?: number;
    accessToken?: string;
    payload?: any;
    signature?: string;
    sessionId?: string;
}>;

/**
 * Grava um novo aceite de consentimento no localStorage do titular.
 * Zero PII: grava apenas hash (SHA-256 de userAgent+purpose+timestamp), timestamp, finalidade, base legal e versão do SDK.
 * Mantém até no máximo 100 registros (FIFO).
 * Falha silenciosamente em caso de erro no localStorage (ex: Safari modo privado ou QuotaExceededError).
 */
export declare function recordConsent(customConsent?: Partial<{
    purpose: string;
    legalBasis: string;
}>): Promise<ConsentRecord | null>;

/** Par de tokens devolvido por {@link refreshSession}. */
export declare interface RefreshedSession {
    accessToken: string;
    refreshToken: string;
}

/**
 * Renova a sessão a partir de um refresh token.
 *
 * O core **rotaciona**: o refresh antigo entra na blacklist e um novo é
 * emitido junto do access. Guarde sempre o par devolvido — reenviar o refresh
 * anterior passa a dar 401.
 *
 * Existe para sessões que duram mais que a validade do access token (o console
 * administrativo é o caso motivador). Fluxos curtos não precisam chamar.
 *
 * @param refreshToken Refresh token vigente, vindo de um login anterior.
 * @param applicationToken Token da aplicação.
 * @throws NeoFaceError `INVALID_TOKEN` se o refresh expirou, já foi usado ou
 *         foi revogado — nesse caso o caminho é refazer o login.
 */
export declare const refreshSession: (refreshToken: string, applicationToken: string) => Promise<RefreshedSession>;

/**
 * Register a new application for a consumer
 * @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
 * @throws NeoFaceError if registration fails
 *
 * @example
 * ```typescript
 * const result = await registerApplication(
 *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
 *   'consumer-uuid-123',
 *   {
 *     applicationName: 'My App',
 *     domain: 'example.com',
 *     acceptOnlyEmailWithSameDomain: true
 *   }
 * );
 * console.log('App Token:', result.application.app_token);
 * ```
 */
export declare const registerApplication: (jwtToken: string, consumerId: string, applicationData: ApplicationRegistrationData) => Promise<ApplicationRegistrationResult>;

/**
 * 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, 
/** NEO-579 · Fix 9 — tipo biométrico: 'FACE' (padrão) ou 'HAND' */
biometricType?: "FACE" | "HAND") => Promise<{
    success: boolean;
    message: string;
    identity_data_id?: string;
    type_of_identification?: string;
    have_biometric_data?: boolean;
    created_at?: string;
}>;

/**
 * Abre a captura de documento (frente e, opcionalmente, verso) e envia as
 * imagens ao core para extração.
 *
 * Substitui `new NeoFaceID(...).registerDocumentByImage(...)`, removido na
 * 2.0.0. Difere de `startDocumentCapture()`, que só captura: esta função
 * também submete ao core. O processamento é assíncrono — use o `taskId`
 * devolvido para acompanhar.
 *
 * @param personId UUID da pessoa (doador já cadastrado).
 * @param jwtToken Bearer do doador autenticado.
 */
export declare function registerDocumentByImage(personId: string, jwtToken: string, options?: RegisterDocumentByImageOptions): Promise<RegisterDocumentResult>;

/** Opções de {@link registerDocumentByImage}. */
export declare interface RegisterDocumentByImageOptions {
    /** Pré-seleciona o tipo de documento, pulando a tela de escolha. */
    preSelectedDocument?: 'RG' | 'CNH' | 'CPF';
    /** Usa a câmera traseira. 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;
    /** NEO-579 · Fix 8 — telefone da pessoa (opcional) */
    phone?: string;
}, 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-10-22";

declare interface RequestChallengeWithSessionParams {
    applicationToken: string;
    purpose: CapturePurpose;
    sessionId?: string;
}

/**
 * Exibe o modal de consentimento e resolve `true` se o titular aceitou,
 * `false` se recusou. Deve ser chamado antes de qualquer `getUserMedia()`.
 *
 * `appName` é obrigatório na prática — omitir gera console.warn e fallback.
 * `flow` decide a copy da terceira linha: 'verification' (padrão) descarta a
 * imagem; 'registration' informa que o vetor biométrico é armazenado.
 */
export declare function requestConsent(info?: ConsentInfo): Promise<boolean>;

/**
 * Pede ao core um token de inscrição de aparelho.
 *
 * Exige **as duas** credenciais ao mesmo tempo: `X-App-Token` da aplicação e o
 * Bearer de um usuário DONOR autenticado (permission `IsDonorOfApplicationConsumer`
 * no core). Por isso a inscrição só existe no autosserviço, com a pessoa logada.
 *
 * O valor devolvido **não é segredo de longa duração**: é um JWT de 5 minutos,
 * de uso único. Não guarde, não reaproveite e não exiba duas vezes.
 *
 * @param userAccessToken Access token do DONOR autenticado.
 * @param applicationToken Token da aplicação.
 */
export declare const requestDeviceEnrollmentToken: (userAccessToken: string, applicationToken: string) => Promise<DeviceEnrollmentToken>;

/**
 * Pede ao servidor a sequência de gestos do desafio de liveness.
 * O SDK apenas exibe e coleta — validação de gesto/yaw/pitch é responsabilidade
 * exclusiva do servidor (regra "client collects, server decides").
 */
export declare function requestLivenessChallenge({ sessionId, applicationToken, }: RequestLivenessChallengeParams): Promise<LivenessChallenge>;

export declare interface RequestLivenessChallengeParams {
    sessionId: string;
    applicationToken: string;
}

/**
 * Garante uma sessão válida e retorna o desafio.
 * Em 410 (sessão expirada), reabre 1x e reenvia. Segunda falha propaga.
 */
export declare function requestLivenessChallengeWithSession({ applicationToken, purpose, sessionId, }: RequestChallengeWithSessionParams): Promise<LivenessChallenge>;

/**
 * Solicita ao core um handle de handoff para que a pessoa continue o
 * onboarding no celular quando a câmera do desktop/kiosk falhou.
 *
 * O handle é curto, opaco e de uso único — é carregado no QR sem expor o
 * `onboardingToken` nem qualquer credencial. O ambiente de destino
 * (sandbox vs. produção) é decidido pelo backend, por aplicação, e devolvido
 * no campo `portalUrl`.
 *
 * @param applicationToken  Token da aplicação (`X-App-Token`).
 * @param onboardingToken   Token do link de onboarding em andamento.
 *
 * @remarks
 * ⚠️  AGUARDA NEO-545 — endpoint ainda não existe no backend.
 *     Ver comentário em {@link OnboardingMobileHandoff}.
 */
export declare const requestOnboardingMobileHandoff: (applicationToken: string, onboardingToken: string) => Promise<OnboardingMobileHandoff>;

/**
 * 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;
}>;

export declare function resetCaptureSession(): void;

declare interface ResolvedTheme {
    mode: ThemeMode;
    tokens: ThemeTokens;
    radius: 8 | 16 | 24;
    accent: string;
    /** True quando o `accent` do integrador foi rejeitado por contraste. */
    accentFellBack: boolean;
}

/**
 * Orquestra:
 * 1. Abre `capture/session`
 * 2. Pede `liveness/challenge` (backend sorteia)
 * 3. Delega a coleta de frames ao consumidor gesto a gesto
 * 4. **Retorna a coleta** para o consumidor submeter no pipeline dele.
 *
 * Retry: em 410 ao abrir sessão/pedir desafio, reabre + refaz 1x. Segunda falha propaga.
 *
 * Nota: até 1.36.1 esta função chamava `submitLivenessChallenge` no fim, mas o
 * endpoint não existe no backend real. NEO-427 removeu essa chamada. Quando
 * NEO-428 identificar o endpoint real de submit, o consumidor pode usá-lo, ou
 * uma variante `runLivenessChallengeAndSubmit` pode ser reintroduzida.
 */
export declare function runLivenessChallenge({ applicationToken, purpose, collectFramesForGesture, retryOnSessionExpired, }: RunLivenessChallengeParams): Promise<RunLivenessChallengeCollectResult>;

/**
 * Resultado da coleta orquestrada. NEO-427: NÃO submete os frames automaticamente
 * (o endpoint de submit `/challenge/{id}/submit/` não existe no backend v1.4.x —
 * devolve 404). O consumidor recebe as gestures coletadas e envia via seu próprio
 * pipeline (ex.: `POST /auth/recognition/face/` com `challenge_response` no body).
 */
export declare interface RunLivenessChallengeCollectResult {
    sessionId: string;
    challenge: LivenessChallenge;
    /** Frames coletados por gesto, na ordem sorteada pelo servidor. */
    capturedGestures: GestureResponse[];
}

export declare interface RunLivenessChallengeParams {
    applicationToken: string;
    purpose: CapturePurpose;
    /**
     * Callback fornecido pelo consumidor: para cada gesto na sequência sorteada
     * pelo servidor, retorna os frames coletados. SDK NÃO decide se o gesto foi
     * cumprido — só coleta; validação é 100% servidor.
     */
    collectFramesForGesture: (gesture: ChallengeGesture, index: number, total: number) => Promise<string[]>;
    /** Se true, quando o servidor devolver 410 na abertura do desafio, reabre sessão + refaz 1x. */
    retryOnSessionExpired?: boolean;
}

/**
 * Configuração interna do SDK
 */
declare interface SDKConfig {
    baseUrl: string;
    applicationToken: string | null;
    environment: Environment | 'custom';
    initialized: boolean;
    appName: string | null;
    accent: string | null;
    radius: SDKRadius;
    theme: SDKTheme;
    locale: string;
    resolvedTheme: ResolvedTheme | null;
    consent: Consent;
    autoFallback: Required<AutoFallbackOptions>;
}

/**
 * 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;
    /**
     * Nome do integrador — mostrado no topo dos modais do SDK ("Banco Exemplo" >
     * NeoFaceID). Obrigatório na prática: omitir gera `console.warn` e cai para o
     * fallback "sua aplicação".
     */
    appName?: string;
    /**
     * Cor de acento do integrador. Pinta APENAS o preenchimento do botão primário.
     * Nunca o anel de captura, o arco de desafio, os colchetes Focus Frame, os
     * glifos ou o selo de resultado — o visor precisa ser idêntico em toda parte
     * para que uma tela falsa não engane.
     *
     * Validado em runtime: contraste vs `#FFFFFF` < 4.5 = fallback para `#0059C4`
     * + `console.warn`. É segurança, não gosto.
     */
    accent?: string;
    /**
     * Raio base dos containers. Restrito aos três raios do sistema: 8, 16 ou 24.
     * Padrão 16. Valor fora dos três permitidos = `console.warn` + fallback 16.
     */
    radius?: SDKRadius;
    /**
     * Modo do tema para a superfície dos modais. Padrão `light`. `auto` respeita
     * `prefers-color-scheme`. O visor de captura é sempre escuro nos dois modos.
     */
    theme?: SDKTheme;
    /**
     * Locale da UI. Padrão `pt-BR`.
     */
    locale?: string;
    /**
     * Dados de consentimento LGPD. Se omitido, o SDK usa defaults conservadores
     * e emite `console.warn` uma única vez.
     */
    consent?: Consent;
    /**
     * Quedas automáticas de canal, em dois níveis independentes.
     *
     * O canal mudar é informação de segurança: cair sozinho esconde do usuário
     * que a verificação passou a acontecer em outro lugar. Por isso o nível 1
     * nasce desligado e precisa ser pedido.
     *
     * ```
     * nível 0  rosto no dispositivo atual
     *          ├─ purpose exige push, ou câmera ausente/negada → nível 1
     *          └─ ok → fim
     *
     * nível 1  confirmar no celular            (toPhone, default false)
     *          ├─ core diz que não há aparelho → nível 2
     *          ├─ prazo expirou                → nível 2
     *          └─ RECUSADO no celular          → falha terminal, não cascateia
     *
     * nível 2  e-mail + senha                  (toPassword, default true)
     * ```
     *
     * A recusa não cai para senha de propósito: se caísse, quem disparou o
     * pedido e levou "não" entraria pelo outro caminho, e o controle não valeria
     * nada. Só expiração e ausência de aparelho cascateiam.
     */
    autoFallback?: AutoFallbackOptions;
}

export declare type SDKRadius = 8 | 16 | 24;

export declare type SDKTheme = 'light' | 'dark' | 'auto';

/**
 * 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;
    };
}>;

/**
 * Frame SSE do core.
 *
 * O core emite `data: {json}\n\n` **sem linha `event:`**
 * (`core/sse_notification_service.py:_format_sse_message`). Pela spec SSE, um
 * frame sem `event:` é despachado como o tipo default `message` — então
 * `addEventListener('success', …)` nunca dispara. Quem discrimina é o campo
 * `status` do payload.
 */
export declare interface SseFrame {
    task_id?: string;
    status?: string;
    timestamp?: number;
    data?: Record<string, unknown>;
    message?: string;
    error?: string;
}

/** Veredito do classificador para cada frame recebido. */
export declare type SseVerdict<T> = {
    kind: 'pending';
} | {
    kind: 'resolve';
    value: T;
} | {
    kind: 'reject';
    error: NeoFaceError;
};

export declare function start(applicationToken: string, callbacks: Callbacks, options?: {
    appName?: string;
    /** NEO-410 · US14.3 — botão "Não consigo fazer esse movimento" visível desde o 1º desafio. */
    onCannotGesture?: () => void;
}): 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;
    /** NEO-579 · Fix 8 — telefone da pessoa (opcional) */
    phone?: string;
}, applicationToken: string, callbacks: BiometricRegistrationCallbacks, options?: {
    useRealApi?: boolean;
    appName?: string;
    /** NEO-410 · US14.3 — botão "Não consigo fazer esse movimento" visível desde o 1º desafio. */
    onCannotGesture?: () => void;
    /** NEO-579 · Fix 5 — guia de voz. */
    voiceGuidance?: boolean;
    /** NEO-579 · Fix 7 — rastreabilidade sem PII. */
    onEvent?: (event: CaptureEvent) => void;
}): void;

/**
 * Abre a tela de handoff para celular quando a câmera falhou no onboarding.
 *
 * Exibe um QR com o handle curto (nunca credencial), um link clicável para
 * quem já está no celular e um cronômetro. Trata expiração e código já usado.
 *
 * O ambiente de destino (sandbox vs. produção) é decidido pelo backend e
 * devolvido no campo `portalUrl` — nunca derivado de hostname ou build flag.
 *
 * ⚠️  AGUARDA NEO-545 — o endpoint que emite o handle ainda não existe.
 *
 * @example
 * ```ts
 * const outcome = await startCameraMobileHandoff({
 *   applicationToken: TOKEN,
 *   onboardingToken: ONBOARDING_TOKEN,
 * });
 * // outcome.status: 'dismissed' | 'expired' | 'already_used'
 * ```
 */
export declare function startCameraMobileHandoff(options: StartCameraMobileHandoffOptions): Promise<CameraMobileHandoffOutcome>;

export declare interface StartCameraMobileHandoffOptions {
    applicationToken: string;
    onboardingToken: string;
}

/**
 * Abre o fluxo de inscrição de aparelho: mostra o código, aguarda o celular
 * lê-lo e confirma o vínculo.
 *
 * Exige uma pessoa autenticada — o core pede o Bearer do DONOR junto do
 * `X-App-Token`, e por isso a inscrição só existe no autosserviço.
 *
 * O QR carrega o **handle curto**, nunca o JWT: um código denso exige tela
 * grande e câmera boa, e o token inteiro ficaria exposto em qualquer foto da
 * tela. Quem resolve o handle é a plataforma Push, contra o core, por canal
 * interno — o navegador não participa dessa troca.
 *
 * @example
 * ```ts
 * const r = await startDeviceEnrollment({
 *   userAccessToken: sessao.accessToken,
 *   applicationToken: TOKEN,
 * });
 * if (r.status === 'enrolled') {
 *   // r.deviceLabel pode ser null enquanto o Push não envia o rótulo
 * }
 * ```
 */
export declare function startDeviceEnrollment(options: StartDeviceEnrollmentOptions): Promise<DeviceEnrollmentOutcome>;

export declare interface StartDeviceEnrollmentOptions {
    /**
     * Access token do DONOR autenticado. A inscrição só existe no autosserviço,
     * com a pessoa logada — o core exige este Bearer **junto** do `X-App-Token`.
     */
    userAccessToken: string;
    applicationToken: string;
    /** Nome do integrador (fallback: `init({ appName })`). */
    appName?: string;
}

/**
 * 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(err: NeoFaceError): void;
    onCancel?(): void;
}, options?: {
    appName?: string;
    /** NEO-410 · US14.3 — botão "Não consigo fazer esse movimento" visível desde o 1º desafio. */
    onCannotGesture?: () => void;
    /** NEO-579 · Fix 5 — guia de voz. */
    voiceGuidance?: boolean;
    /** NEO-579 · Fix 7 — rastreabilidade sem PII. */
    onEvent?: (event: CaptureEvent) => 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.
 *
 * NEO-456: quando a câmera falha (ErrorType.CAMERA_ERROR ou NO_CAMERA), e
 * `enableMobileHandoff` não for `false`, abre automaticamente a tela de QR
 * para que a pessoa continue no celular.
 *
 * ⚠️  O QR de handoff aguarda o merge do NEO-545 (endpoint backend).
 */
export declare const startOnboarding: (options: StartOnboardingOptions) => Promise<void>;

export declare interface StartOnboardingOptions {
    applicationToken: string;
    onboardingToken: string;
    countdown?: number;
    title?: string;
    subtitle?: string;
    /** Nome do integrador exibido no topo do modal de consentimento (US14.2). */
    appName?: string;
    /**
     * NEO-456 · Controla se a falha de câmera deve oferecer o QR de handoff
     * para o celular. Default: `true`.
     *
     * Passe `false` apenas se o consumidor quiser tratar o erro de câmera
     * inteiramente pelo callback `onError` sem mostrar a tela de QR.
     *
     * ⚠️  O QR só funciona após o merge do NEO-545 (backend).
     */
    enableMobileHandoff?: boolean;
    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;
}

/**
 * @deprecated NEO-427: o endpoint `POST /liveness/challenge/{id}/submit/` NÃO
 * EXISTE no backend v1.4.x — devolve 404. `runLivenessChallenge` não chama mais
 * esta função. Mantida apenas para consumidores que ainda dependem do símbolo;
 * será removida quando o endpoint real de submit for identificado (NEO-428).
 *
 * Continua tentando o path histórico e propaga o erro do servidor.
 */
export declare function submitLivenessChallenge({ challengeId, sessionId, applicationToken, gestures, }: SubmitLivenessChallengeParams): Promise<LivenessChallengeResult>;

export declare interface SubmitLivenessChallengeParams {
    /** Opcional no v1.4.x — backend rastreia via session_id. */
    challengeId?: string;
    sessionId: string;
    applicationToken: string;
    gestures: GestureResponse[];
}

declare type ThemeMode = 'light' | 'dark';

/** Tokens semânticos por tema — o que os componentes consomem. */
declare interface ThemeTokens {
    ground: string;
    surface: string;
    surfaceMuted: string;
    line: string;
    text: string;
    textMuted: string;
    textSubtle: string;
    action: string;
    actionText: string;
    accent: string;
    overlay: string;
    focusRing: string;
}

/**
 * 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 = "2.8.0";

/**
 * Executa `fn(sessionId)`. Se o servidor devolver 410 (sessão consumida/expirada),
 * reabre a sessão automaticamente 1x e reexecuta. Segunda falha propaga.
 */
export declare function withCaptureSession<T>(params: OpenCaptureSessionParams, fn: (sessionId: string) => Promise<T>): Promise<T>;

/**
 * Injeta `session_id` cacheado no payload. Se não houver sessão aberta,
 * retorna o payload original inalterado — a decisão de exigir sessão
 * fica no servidor.
 */
export declare function withSessionId<T extends Record<string, unknown>>(payload: T): T & {
    session_id?: string;
};

export { }