@neofaceid/web-sdk 1.1.1 → 1.3.0

package/dist/neoface-id-sdk.es.js

@@ -1108,6 +1108,7 @@ const useCamera = () => {
 };
 var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2["NETWORK"] = "NetworkError";
+  ErrorType2["NETWORK_ERROR"] = "NetworkError";
   ErrorType2["INVALID_TOKEN"] = "InvalidTokenError";
   ErrorType2["RECOGNITION_FAILED"] = "RecognitionFailedError";
   ErrorType2["LOGIN_FAILED"] = "LoginFailedError";
@@ -1115,12 +1116,18 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2["API_ERROR"] = "ApiError";
   ErrorType2["PERSON_NOT_FOUND"] = "PersonNotFoundError";
   ErrorType2["INITIALIZATION_ERROR"] = "InitializationError";
-  ErrorType2["NETWORK_ERROR"] = "NetworkError";
   ErrorType2["CAMERA_ERROR"] = "CameraError";
   ErrorType2["CAPTURE_ERROR"] = "CaptureError";
+  ErrorType2["NOT_FOUND"] = "NotFoundError";
+  ErrorType2["UNKNOWN"] = "UnknownError";
   return ErrorType2;
 })(ErrorType || {});
 class NeoFaceError extends Error {
+  /**
+   * Constrói um erro do SDK com mensagem e tipo categórico.
+   * @param message Mensagem descritiva do erro
+   * @param type Tipo categórico do erro
+   */
   constructor(message, type) {
     super(message);
     __publicField(this, "type");
@@ -1197,6 +1204,92 @@ const validateToken = async (applicationToken) => {
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
+const getOnboardingDetails = async (applicationToken, onboardingToken) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/v1/onboardings/${encodeURIComponent(onboardingToken)}/`, {
+      method: "GET",
+      headers: {
+        "X-App-Token": applicationToken
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Token de aplicação inválido ou expirado", ErrorType.INVALID_TOKEN);
+      }
+      if (response.status === 404) {
+        throw new NeoFaceError("Link de onboarding não encontrado", ErrorType.NOT_FOUND);
+      }
+      throw new NeoFaceError(`Falha ao obter detalhes (${response.status})`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Tempo de requisição excedido", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Erro desconhecido", ErrorType.NETWORK_ERROR);
+  }
+};
+const completeOnboarding = async (applicationToken, onboardingToken, faceImage, documentImage) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  const compressedFace = await compressImage(faceImage);
+  const compressedDocument = await compressImage(documentImage);
+  try {
+    const formData = new FormData();
+    formData.append("face_image", compressedFace, "face.jpg");
+    formData.append("document_image", compressedDocument, "document.jpg");
+    const response = await fetch(
+      `${API_BASE_URL}/api/v1/onboardings/${encodeURIComponent(onboardingToken)}/complete`,
+      {
+        method: "POST",
+        headers: {
+          "X-App-Token": applicationToken
+        },
+        body: formData,
+        signal: controller.signal
+      }
+    );
+    const data = await response.json();
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Token de aplicação inválido ou expirado", ErrorType.INVALID_TOKEN);
+      }
+      if (response.status === 404) {
+        throw new NeoFaceError("Link de onboarding não encontrado", ErrorType.NOT_FOUND);
+      }
+      throw new NeoFaceError((data == null ? void 0 : data.error) || (data == null ? void 0 : data.message) || "Falha ao concluir onboarding", ErrorType.NETWORK);
+    }
+    return {
+      success: !!data.success,
+      message: data.message || "Onboarding concluído",
+      person_id: data.person_id,
+      identity_data_id: data.identity_data_id,
+      confidence_score: data.confidence_score,
+      processing_time: data.processing_time
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Tempo de requisição excedido", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Erro desconhecido", ErrorType.NETWORK_ERROR);
+  }
+};
 const recognize = async (image, applicationToken) => {
   ensureSecureContext();
   const controller = createTimeoutController();
@@ -1485,10 +1578,10 @@ const registerPersonWithoutFace = async (personData, applicationToken) => {
 const registerPersonWithBiometric = async (personData, facePhotos, applicationToken) => {
   ensureSecureContext();
   if (!facePhotos || facePhotos.length === 0) {
-    throw new NeoFaceError("At least one face photo is required for biometric registration", ErrorType.VALIDATION);
+    throw new NeoFaceError("At least one face photo is required for biometric registration", ErrorType.VALIDATION_ERROR);
   }
   if (facePhotos.length > 5) {
-    throw new NeoFaceError("Maximum of 5 face photos allowed", ErrorType.VALIDATION);
+    throw new NeoFaceError("Maximum of 5 face photos allowed", ErrorType.VALIDATION_ERROR);
   }
   const controller = createTimeoutController();
   try {
@@ -1530,13 +1623,13 @@ const registerPersonWithBiometric = async (personData, facePhotos, applicationTo
       try {
         const errorData = await response.json();
         if (errorData.error === "fraud_detected") {
-          throw new NeoFaceError("Fraud detected in biometric images. Registration blocked.", ErrorType.VALIDATION);
+          throw new NeoFaceError("Fraud detected in biometric images. Registration blocked.", ErrorType.VALIDATION_ERROR);
         }
         if (errorData.error === "user_exists") {
-          throw new NeoFaceError("User with this email already exists", ErrorType.VALIDATION);
+          throw new NeoFaceError("User with this email already exists", ErrorType.VALIDATION_ERROR);
         }
         if (errorData.error === "person_exists") {
-          throw new NeoFaceError("Person with this CPF already exists", ErrorType.VALIDATION);
+          throw new NeoFaceError("Person with this CPF already exists", ErrorType.VALIDATION_ERROR);
         }
         throw new NeoFaceError(errorData.message || `Server returned status ${response.status}`, ErrorType.NETWORK);
       } catch (parseError) {
@@ -1566,6 +1659,121 @@ const registerPersonWithBiometric = async (personData, facePhotos, applicationTo
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
+const loginWithEmail = async (email, password, applicationToken) => {
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/v1/auth/login/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({ email, password }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid credentials or application token", ErrorType.INVALID_TOKEN);
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return {
+      success: true,
+      // Compatível com diferentes formatos de resposta do backend
+      accessToken: data.access_token || data.access,
+      alias: data.user && data.user.alias || data.alias,
+      user: {
+        id: data.user && data.user.id || "",
+        email: data.user && data.user.email || "",
+        role: data.user && data.user.role || "",
+        validated: data.user && data.user.validated || false,
+        active: data.user && data.user.active || false
+      }
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timed out", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
+  }
+};
+const identifyPerson = async (image, applicationToken) => {
+  var _a, _b;
+  ensureSecureContext();
+  const controller = createTimeoutController();
+  const compressedImage = await compressImage(image);
+  const base64Image = await new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      resolve(result.split(",")[1]);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(compressedImage);
+  });
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/v1/external/recognition/face/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({
+        image: base64Image,
+        purpose: "SIMPLE_IDENTIFICATION_F"
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new NeoFaceError("Invalid or expired application token", ErrorType.INVALID_TOKEN);
+      }
+      throw new NeoFaceError(`Server returned status ${response.status}`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new NeoFaceError(data.message || "Person identification failed", ErrorType.RECOGNITION_FAILED);
+    }
+    const personName = ((_a = data.person) == null ? void 0 : _a.name) || "";
+    const birthDateStr = (_b = data.person) == null ? void 0 : _b.birth_date;
+    if (!personName) {
+      throw new NeoFaceError("Person name not found in response", ErrorType.PERSON_NOT_FOUND);
+    }
+    if (!birthDateStr) {
+      throw new NeoFaceError("Birth date not found in response", ErrorType.PERSON_NOT_FOUND);
+    }
+    const birthDate = new Date(birthDateStr);
+    const today = /* @__PURE__ */ new Date();
+    let age = today.getFullYear() - birthDate.getFullYear();
+    const monthDiff = today.getMonth() - birthDate.getMonth();
+    if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+      age--;
+    }
+    return {
+      name: personName,
+      age
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timed out", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) {
+        throw error;
+      }
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
+  }
+};
 const modalReducer$1 = (state, action) => {
   switch (action.type) {
     case "PERMISSION_GRANTED":
@@ -3169,9 +3377,10 @@ class BiometricCaptureModal {
       context.drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
       const imageData = this.canvas.toDataURL("image/jpeg", 0.8);
       const base64Data = imageData.split(",")[1];
+      const dataUrl = `data:image/jpeg;base64,${base64Data}`;
       let detectedType = this.options.mode === "auto" ? await this.detectBiometricType(base64Data) : this.options.mode;
       this.close();
-      this.options.onSuccess(base64Data, detectedType);
+      this.options.onSuccess(dataUrl, detectedType);
     } catch (error) {
       this.options.onError(
         new NeoFaceError(
@@ -3507,6 +3716,70 @@ class BiometricCaptureModal {
     document.head.appendChild(style);
   }
 }
+class EmailPasswordModal {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "modalElement", null);
+    this.options = options;
+  }
+  /**
+   * Abre o modal de login com email e senha.
+   */
+  async open() {
+    this.createModal();
+    document.body.appendChild(this.modalElement);
+  }
+  /**
+   * Fecha o modal.
+   */
+  close() {
+    if (this.modalElement) {
+      document.body.removeChild(this.modalElement);
+      this.modalElement = null;
+    }
+    if (this.options.onCancel) {
+      this.options.onCancel();
+    }
+  }
+  createModal() {
+    this.modalElement = document.createElement("div");
+    this.modalElement.className = "neoface-modal";
+    this.modalElement.innerHTML = `
+      <div class="modal-content">
+        <h2>${this.options.title || "Login com Email e Senha"}</h2>
+        <p>${this.options.subtitle || "Informe seus dados para login."}</p>
+        <form id="email-password-form">
+          <input type="email" id="email" placeholder="Email" required />
+          <input type="password" id="password" placeholder="Senha" required />
+          <button type="submit">Entrar</button>
+        </form>
+        <button class="cancel-button">Cancelar</button>
+      </div>
+    `;
+    const form = this.modalElement.querySelector("#email-password-form");
+    form.addEventListener("submit", this.handleSubmit.bind(this));
+    const cancelButton = this.modalElement.querySelector(".cancel-button");
+    cancelButton.addEventListener("click", this.close.bind(this));
+  }
+  async handleSubmit(event) {
+    event.preventDefault();
+    const emailInput = this.modalElement.querySelector("#email");
+    const passwordInput = this.modalElement.querySelector("#password");
+    const email = emailInput.value.trim();
+    const password = passwordInput.value.trim();
+    if (!email || !password) {
+      this.options.onError(new NeoFaceError("Email e senha são obrigatórios", ErrorType.VALIDATION_ERROR));
+      return;
+    }
+    try {
+      const result = await loginWithEmail(email, password, this.options.applicationToken);
+      this.options.onSuccess(result);
+      this.close();
+    } catch (error) {
+      this.options.onError(error);
+    }
+  }
+}
 async function startFaceLogin(options) {
   try {
     const isValidToken = await validateToken(options.applicationToken);
@@ -3542,6 +3815,134 @@ async function startFaceLogin(options) {
     );
   }
 }
+async function startHandLogin(options) {
+  try {
+    const isValidToken = await validateToken(options.applicationToken);
+    if (!isValidToken) {
+      options.onError(new NeoFaceError("Token de aplicação inválido", ErrorType.INVALID_TOKEN));
+      return;
+    }
+    const captureOptions = {
+      mode: "hand",
+      onSuccess: async (imageData, _detectedType) => {
+        try {
+          const imageBlob = await fetch(imageData).then((res) => res.blob());
+          const result = await loginWithBiometric(imageBlob, options.applicationToken);
+          options.onSuccess(result);
+        } catch (error) {
+          options.onError(error);
+        }
+      },
+      onError: options.onError,
+      onCancel: options.onCancel,
+      countdown: options.countdown,
+      title: options.title || "Login por Mão",
+      subtitle: options.subtitle || "Posicione sua mão dentro do quadro para fazer login."
+    };
+    const modal = new BiometricCaptureModal(captureOptions);
+    await modal.open();
+  } catch (error) {
+    options.onError(
+      new NeoFaceError(
+        "Erro ao inicializar login por mão: " + error.message,
+        ErrorType.INITIALIZATION_ERROR
+      )
+    );
+  }
+}
+async function startAutoLogin(options) {
+  try {
+    const isValidToken = await validateToken(options.applicationToken);
+    if (!isValidToken) {
+      options.onError(new NeoFaceError("Token de aplicação inválido", ErrorType.INVALID_TOKEN));
+      return;
+    }
+    const captureOptions = {
+      mode: "auto",
+      onSuccess: async (imageData, _detectedType) => {
+        try {
+          const imageBlob = await fetch(imageData).then((res) => res.blob());
+          const result = await loginWithBiometric(imageBlob, options.applicationToken);
+          options.onSuccess(result);
+        } catch (error) {
+          options.onError(error);
+        }
+      },
+      onError: options.onError,
+      onCancel: options.onCancel,
+      countdown: options.countdown,
+      title: options.title || "Login Biométrico",
+      subtitle: options.subtitle || "Posicione seu rosto ou mão dentro do quadro para login automático."
+    };
+    const modal = new BiometricCaptureModal(captureOptions);
+    await modal.open();
+  } catch (error) {
+    options.onError(
+      new NeoFaceError(
+        "Erro ao inicializar login automático: " + error.message,
+        ErrorType.INITIALIZATION_ERROR
+      )
+    );
+  }
+}
+function biometricLogin(applicationToken, mode = "auto") {
+  return new Promise((resolve, reject) => {
+    const options = {
+      applicationToken,
+      onSuccess: resolve,
+      onError: reject
+    };
+    switch (mode) {
+      case "face":
+        startFaceLogin(options);
+        break;
+      case "hand":
+        startHandLogin(options);
+        break;
+      case "auto":
+        startAutoLogin(options);
+        break;
+      default:
+        reject(new NeoFaceError("Modo de login inválido", ErrorType.VALIDATION_ERROR));
+    }
+  });
+}
+function biometricLoginWithFallback(applicationToken, mode = "auto") {
+  return new Promise((resolve, reject) => {
+    const options = {
+      applicationToken,
+      onSuccess: resolve,
+      onError: (error) => {
+        if (error.type === ErrorType.LOGIN_FAILED) {
+          const fallbackOptions = {
+            applicationToken,
+            onSuccess: resolve,
+            onError: reject,
+            title: "Login Alternativo",
+            subtitle: "Biometria não reconhecida. Por favor, informe email e senha."
+          };
+          const modal = new EmailPasswordModal(fallbackOptions);
+          modal.open();
+        } else {
+          reject(error);
+        }
+      }
+    };
+    switch (mode) {
+      case "face":
+        startFaceLogin(options);
+        break;
+      case "hand":
+        startHandLogin(options);
+        break;
+      case "auto":
+        startAutoLogin(options);
+        break;
+      default:
+        reject(new NeoFaceError("Modo de login inválido", ErrorType.VALIDATION_ERROR));
+    }
+  });
+}
 async function detectBiometricType(imageData) {
   try {
     const img = await loadImageFromBase64(imageData);
@@ -3578,7 +3979,8 @@ async function detectFace(img) {
     if (typeof window !== "undefined" && window.faceapi) {
       const faceapi2 = window.faceapi;
       await loadFaceApiModels();
-      const detections = await faceapi2.detectAllFaces(img).withFaceLandmarks().withFaceDescriptors();
+      const tinyOptions = new faceapi2.TinyFaceDetectorOptions({ inputSize: 320, scoreThreshold: 0.5 });
+      const detections = await faceapi2.detectAllFaces(img, tinyOptions).withFaceLandmarks();
       if (detections && detections.length > 0) {
         const bestDetection = detections.reduce(
           (best, current) => current.detection.score > best.detection.score ? current : best
@@ -3683,8 +4085,7 @@ async function loadFaceApiModels() {
   try {
     await Promise.all([
       faceapi2.nets.tinyFaceDetector.loadFromUri("./models"),
-      faceapi2.nets.faceLandmark68Net.loadFromUri("./models"),
-      faceapi2.nets.faceRecognitionNet.loadFromUri("./models")
+      faceapi2.nets.faceLandmark68Net.loadFromUri("./models")
     ]);
   } catch (error) {
     console.warn("Não foi possível carregar modelos do face-api.js:", error);
@@ -3708,8 +4109,231 @@ const biometricDetection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.
   initializeBiometricDetection,
   isAdvancedDetectionAvailable
 }, Symbol.toStringTag, { value: "Module" }));
-const VERSION = "1.1.1";
-const RELEASE_DATE = "2025-11-02";
+const VERSION = "1.3.0";
+const RELEASE_DATE = "2025-11-17";
+class OnboardingCaptureModal {
+  constructor(options) {
+    __publicField(this, "overlay", null);
+    __publicField(this, "video", null);
+    __publicField(this, "canvas", null);
+    __publicField(this, "stream", null);
+    __publicField(this, "step", "face");
+    __publicField(this, "countdownSeconds");
+    __publicField(this, "title");
+    __publicField(this, "subtitle");
+    __publicField(this, "faceBlob", null);
+    __publicField(this, "documentBlob", null);
+    this.countdownSeconds = (options == null ? void 0 : options.countdown) ?? 3;
+    this.title = options == null ? void 0 : options.title;
+    this.subtitle = options == null ? void 0 : options.subtitle;
+  }
+  /**
+   * Abre o modal, inicia câmera e gerencia o fluxo de captura dos dois passos.
+   * Retorna uma promessa resolvida com os Blobs de face e documento.
+   */
+  async open() {
+    await this.createDom();
+    await this.startCamera();
+    await this.runFaceCaptureCountdown();
+    this.faceBlob = await this.captureFrame();
+    this.step = "document";
+    this.updateTexts("Captura do Documento", 'Posicione seu documento visível e clique em "Capturar"');
+    await this.waitForUserCaptureClick();
+    this.documentBlob = await this.captureFrame();
+    await this.close();
+    if (!this.faceBlob || !this.documentBlob) {
+      throw new Error("Falha na captura das imagens de onboarding");
+    }
+    return { face: this.faceBlob, document: this.documentBlob };
+  }
+  /**
+   * Cria estrutura de DOM do modal e elementos de UI.
+   */
+  async createDom() {
+    const overlay = document.createElement("div");
+    overlay.className = "neofaceid-modal-overlay";
+    overlay.innerHTML = `
+      <div class="neofaceid-modal">
+        <div class="neofaceid-modal-header">
+          <h2 class="neofaceid-title">${this.title ?? "Onboarding NeoFaceID"}</h2>
+          <button class="neofaceid-close-btn" aria-label="Fechar">×</button>
+        </div>
+        <div class="neofaceid-modal-body">
+          <p class="neofaceid-subtitle">${this.subtitle ?? "Vamos capturar sua face e documento"}</p>
+          <div class="neofaceid-camera-container">
+            <video class="neofaceid-video" autoplay playsinline></video>
+            <canvas class="neofaceid-canvas"></canvas>
+            <div class="neofaceid-overlay">
+              <div class="neofaceid-frame"></div>
+              <div class="neofaceid-countdown" style="display:none"><span class="neofaceid-countdown-number">${this.countdownSeconds}</span></div>
+            </div>
+          </div>
+          <div class="neofaceid-status"><p class="neofaceid-status-text">Posicione seu rosto no quadro</p></div>
+        </div>
+        <div class="neofaceid-modal-footer">
+          <button class="neofaceid-cancel-btn">Cancelar</button>
+          <button class="neofaceid-capture-btn" disabled>Capturar</button>
+        </div>
+      </div>
+    `;
+    const style = document.createElement("style");
+    style.textContent = `
+      .neofaceid-modal-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.6); display:flex; align-items:center; justify-content:center; z-index: 9999; }
+      .neofaceid-modal { background:#fff; border-radius:12px; width: 92%; max-width: 640px; box-shadow: 0 20px 60px rgba(0,0,0,0.3); overflow:hidden; }
+      .neofaceid-modal-header { padding: 16px 20px; border-bottom: 1px solid #eee; display:flex; align-items:center; justify-content:space-between; }
+      .neofaceid-title { margin:0; font-size: 20px; color:#333; }
+      .neofaceid-close-btn { background:none; border:none; font-size:24px; cursor:pointer; color:#666; }
+      .neofaceid-modal-body { padding: 16px 20px; }
+      .neofaceid-subtitle { margin: 0 0 12px 0; color:#666; }
+      .neofaceid-camera-container { position: relative; background:#000; border-radius:8px; overflow:hidden; aspect-ratio: 4/3; margin-bottom: 12px; }
+      .neofaceid-video { width:100%; height:100%; object-fit: cover; }
+      .neofaceid-canvas { position:absolute; top:0; left:0; }
+      .neofaceid-overlay { position:absolute; inset:0; display:flex; align-items:center; justify-content:center; }
+      .neofaceid-frame { width: 200px; height: 200px; border: 3px solid #4CAF50; border-radius: 50%; box-shadow: 0 0 0 2px rgba(76,175,80,0.3); }
+      .neofaceid-countdown { position:absolute; top:16px; right:16px; background: rgba(0,0,0,0.7); color:#fff; width: 48px; height:48px; display:flex; align-items:center; justify-content:center; border-radius:50%; }
+      .neofaceid-modal-footer { padding: 16px 20px; border-top: 1px solid #eee; display:flex; gap: 8px; justify-content:flex-end; }
+      .neofaceid-cancel-btn { background:#f5f5f5; color:#666; border:none; border-radius:6px; padding:10px 18px; cursor:pointer; }
+      .neofaceid-capture-btn { background:#4CAF50; color:#fff; border:none; border-radius:6px; padding:10px 18px; cursor:pointer; }
+      .neofaceid-capture-btn:disabled { background:#ccc; cursor:not-allowed; }
+    `;
+    document.head.appendChild(style);
+    document.body.appendChild(overlay);
+    this.overlay = overlay;
+    this.video = this.overlay.querySelector(".neofaceid-video");
+    this.canvas = this.overlay.querySelector(".neofaceid-canvas");
+    const closeBtn = this.overlay.querySelector(".neofaceid-close-btn");
+    const cancelBtn = this.overlay.querySelector(".neofaceid-cancel-btn");
+    closeBtn.onclick = () => this.close();
+    cancelBtn.onclick = () => this.close();
+    const captureBtn = this.overlay.querySelector(".neofaceid-capture-btn");
+    captureBtn.disabled = true;
+  }
+  /**
+   * Inicia a câmera do usuário com resolução adequada.
+   */
+  async startCamera() {
+    const constraints = {
+      video: { facingMode: "user", width: { ideal: 1280 }, height: { ideal: 720 } },
+      audio: false
+    };
+    this.stream = await navigator.mediaDevices.getUserMedia(constraints);
+    if (!this.video)
+      throw new Error("Elemento de vídeo não encontrado");
+    this.video.srcObject = this.stream;
+    await this.video.play();
+  }
+  /**
+   * Executa a contagem regressiva e atualiza textos para captura de rosto.
+   */
+  async runFaceCaptureCountdown() {
+    if (!this.overlay)
+      return;
+    const countdownEl = this.overlay.querySelector(".neofaceid-countdown");
+    const countdownNumberEl = this.overlay.querySelector(".neofaceid-countdown-number");
+    const statusText = this.overlay.querySelector(".neofaceid-status-text");
+    countdownEl.style.display = "flex";
+    statusText.textContent = "Prepare-se! Capturando seu rosto...";
+    let remaining = this.countdownSeconds;
+    countdownNumberEl.textContent = String(remaining);
+    await new Promise((resolve) => {
+      const interval = setInterval(() => {
+        remaining -= 1;
+        countdownNumberEl.textContent = String(remaining);
+        if (remaining <= 0) {
+          clearInterval(interval);
+          countdownEl.style.display = "none";
+          resolve();
+        }
+      }, 1e3);
+    });
+  }
+  /**
+   * Aguarda o clique do usuário no botão "Capturar" (para documento).
+   */
+  async waitForUserCaptureClick() {
+    if (!this.overlay)
+      return;
+    const captureBtn = this.overlay.querySelector(".neofaceid-capture-btn");
+    const statusText = this.overlay.querySelector(".neofaceid-status-text");
+    captureBtn.disabled = false;
+    statusText.textContent = 'Clique em "Capturar" quando o documento estiver visível';
+    await new Promise((resolve) => {
+      const handler = () => {
+        captureBtn.removeEventListener("click", handler);
+        resolve();
+      };
+      captureBtn.addEventListener("click", handler);
+    });
+    captureBtn.disabled = true;
+  }
+  /**
+   * Captura o frame atual do vídeo e retorna como Blob JPEG.
+   */
+  async captureFrame() {
+    if (!this.video || !this.canvas)
+      throw new Error("Elementos de captura não encontrados");
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx)
+      throw new Error("Falha ao obter contexto do canvas");
+    this.canvas.width = this.video.videoWidth;
+    this.canvas.height = this.video.videoHeight;
+    ctx.drawImage(this.video, 0, 0, this.canvas.width, this.canvas.height);
+    const blob = await new Promise((resolve, reject) => {
+      this.canvas.toBlob((b) => b ? resolve(b) : reject(new Error("Falha ao gerar imagem")), "image/jpeg", 0.92);
+    });
+    return blob;
+  }
+  /**
+   * Atualiza título e subtítulo do modal conforme o passo.
+   */
+  updateTexts(title, subtitle) {
+    if (!this.overlay)
+      return;
+    const titleEl = this.overlay.querySelector(".neofaceid-title");
+    const subtitleEl = this.overlay.querySelector(".neofaceid-subtitle");
+    const frameEl = this.overlay.querySelector(".neofaceid-frame");
+    titleEl.textContent = title;
+    subtitleEl.textContent = subtitle;
+    if (this.step === "document") {
+      frameEl.style.borderRadius = "8px";
+      frameEl.style.width = "280px";
+      frameEl.style.height = "180px";
+    }
+  }
+  /**
+   * Fecha o modal e libera a câmera.
+   */
+  async close() {
+    if (this.stream) {
+      this.stream.getTracks().forEach((t) => t.stop());
+      this.stream = null;
+    }
+    if (this.overlay) {
+      this.overlay.remove();
+      this.overlay = null;
+    }
+  }
+}
+const startOnboarding = async (options) => {
+  const { applicationToken, onboardingToken, countdown, title, subtitle, onSuccess, onError } = options;
+  try {
+    const details = await getOnboardingDetails(applicationToken, onboardingToken);
+    if (!(details == null ? void 0 : details.is_valid)) {
+      throw new NeoFaceError("Link de onboarding inválido ou expirado", ErrorType.VALIDATION_ERROR);
+    }
+    const modal = new OnboardingCaptureModal({ countdown, title, subtitle });
+    const { face, document: document2 } = await modal.open();
+    const result = await completeOnboarding(applicationToken, onboardingToken, face, document2);
+    onSuccess({ ...result, details });
+  } catch (err) {
+    if (err instanceof NeoFaceError) {
+      onError(err);
+      return;
+    }
+    const message = (err == null ? void 0 : err.message) || "Erro desconhecido no onboarding";
+    onError(new NeoFaceError(message, ErrorType.UNKNOWN));
+  }
+};
 function start(applicationToken, callbacks) {
   const container = document.createElement("div");
   container.id = "neoface-modal-container";
@@ -3779,7 +4403,10 @@ export {
   NeoFaceError,
   RELEASE_DATE,
   VERSION,
+  biometricLogin,
+  biometricLoginWithFallback,
   detectBiometricType,
+  identifyPerson,
   initializeBiometricDetection,
   isAdvancedDetectionAvailable,
   loginWithBiometric,
@@ -3790,8 +4417,11 @@ export {
   registerPersonWithoutFace,
   simpleIdentification,
   start,
+  startAutoLogin,
   startBiometricRegistration,
   startFaceLogin,
+  startHandLogin,
+  startOnboarding,
   validateToken
 };
 //# sourceMappingURL=neoface-id-sdk.es.js.map