@neofaceid/web-sdk 1.2.0 → 1.4.0

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

@@ -1239,6 +1239,41 @@ const getOnboardingDetails = async (applicationToken, onboardingToken) => {
     throw new NeoFaceError("Erro desconhecido", ErrorType.NETWORK_ERROR);
   }
 };
+const validateOnboardingToken = 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) {
+        return false;
+      }
+      throw new NeoFaceError(`Falha ao validar token (${response.status})`, ErrorType.NETWORK);
+    }
+    const data = await response.json();
+    return (data == null ? void 0 : data.is_valid) === true;
+  } 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();
@@ -1290,6 +1325,82 @@ const completeOnboarding = async (applicationToken, onboardingToken, faceImage,
     throw new NeoFaceError("Erro desconhecido", ErrorType.NETWORK_ERROR);
   }
 };
+const completeOnboardingWithData = async (applicationToken, onboardingToken, personData, personImages, documentImage) => {
+  ensureSecureContext();
+  if (!personImages || personImages.length === 0) {
+    throw new NeoFaceError("Pelo menos uma imagem da pessoa é obrigatória", ErrorType.VALIDATION_ERROR);
+  }
+  const controller = createTimeoutController();
+  try {
+    const compressedPersonImages = await Promise.all(
+      personImages.map((img) => compressImage(img))
+    );
+    const compressedDocument = await compressImage(documentImage);
+    const formData = new FormData();
+    compressedPersonImages.forEach((img, index) => {
+      formData.append("person_images", img, `person_${index + 1}.jpg`);
+    });
+    formData.append("document_image", compressedDocument, "document.jpg");
+    if (personData.name) {
+      formData.append("name", personData.name);
+    }
+    if (personData.birth_date) {
+      formData.append("birth_date", personData.birth_date);
+    }
+    if (personData.cpf) {
+      formData.append("cpf", personData.cpf);
+    }
+    if (personData.cnpj) {
+      formData.append("cnpj", personData.cnpj);
+    }
+    if (personData.email) {
+      formData.append("email", personData.email);
+    }
+    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 com sucesso",
+      person_id: data.person_id,
+      identity_data_id: data.identity_data_id,
+      confidence_score: data.confidence_score,
+      processing_time: data.processing_time,
+      liveness_passed: data.liveness_passed,
+      document_verified: data.document_verified,
+      person_created: data.person_created
+    };
+  } 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();
@@ -1332,7 +1443,7 @@ const recognize = async (image, applicationToken) => {
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK_ERROR);
   }
 };
-const loginWithBiometric = async (image, applicationToken) => {
+const loginWithBiometric$1 = async (image, applicationToken) => {
   var _a, _b, _c, _d, _e;
   ensureSecureContext();
   const controller = createTimeoutController();
@@ -1705,6 +1816,75 @@ const loginWithEmail = async (email, password, applicationToken) => {
     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":
@@ -3147,7 +3327,7 @@ function BiometricRegistrationModal({
     /* @__PURE__ */ jsxRuntimeExports.jsx("canvas", { ref: canvasRef })
   ] });
 }
-class BiometricCaptureModal {
+let BiometricCaptureModal$1 = class BiometricCaptureModal2 {
   constructor(options) {
     __publicField(this, "modal", null);
     __publicField(this, "video", null);
@@ -3646,97 +3826,1106 @@ 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);
-    if (!isValidToken) {
-      options.onError(new NeoFaceError("Token de aplicação inválido", ErrorType.INVALID_TOKEN));
-      return;
+};
+function BiometricStatusOverlayComponent({ status, onClose }) {
+  const [isVisible, setIsVisible] = useState(true);
+  useEffect(() => {
+    if (status === "success") {
+      const timer = setTimeout(() => {
+        setIsVisible(false);
+        setTimeout(() => {
+          onClose == null ? void 0 : onClose();
+        }, 300);
+      }, 800);
+      return () => clearTimeout(timer);
     }
-    const captureOptions = {
-      mode: "face",
-      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);
+  }, [status, onClose]);
+  if (!isVisible)
+    return null;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("style", { children: `
+        @keyframes fadeIn {
+          from { opacity: 0; transform: scale(0.9); }
+          to { opacity: 1; transform: scale(1); }
         }
-      },
-      onError: options.onError,
-      onCancel: options.onCancel,
-      countdown: options.countdown,
-      title: options.title || "Login Facial",
-      subtitle: options.subtitle || "Posicione seu rosto dentro do quadro para fazer login."
-    };
-    const modal = new BiometricCaptureModal(captureOptions);
-    await modal.open();
+
+        @keyframes fadeOut {
+          from { opacity: 1; transform: scale(1); }
+          to { opacity: 0; transform: scale(0.9); }
+        }
+
+        @keyframes pulse {
+          0%, 100% { 
+            transform: scale(1);
+            opacity: 1;
+          }
+          50% { 
+            transform: scale(1.1);
+            opacity: 0.9;
+          }
+        }
+
+        @keyframes spin {
+          from { transform: rotate(0deg); }
+          to { transform: rotate(360deg); }
+        }
+
+        @keyframes checkmark {
+          0% {
+            stroke-dashoffset: 100;
+            opacity: 0;
+          }
+          50% {
+            opacity: 1;
+          }
+          100% {
+            stroke-dashoffset: 0;
+            opacity: 1;
+          }
+        }
+
+        @keyframes errorShake {
+          0%, 100% { transform: translateX(0) scale(1); }
+          10%, 30%, 50%, 70%, 90% { transform: translateX(-4px) scale(1); }
+          20%, 40%, 60%, 80% { transform: translateX(4px) scale(1); }
+        }
+
+        @keyframes scaleIn {
+          0% {
+            transform: scale(0);
+            opacity: 0;
+          }
+          50% {
+            transform: scale(1.1);
+          }
+          100% {
+            transform: scale(1);
+            opacity: 1;
+          }
+        }
+
+        .neofaceid-overlay-container {
+          position: fixed;
+          top: 0;
+          left: 0;
+          right: 0;
+          bottom: 0;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          z-index: 10000;
+          pointer-events: none;
+          animation: fadeIn 0.3s ease-out;
+        }
+
+        .neofaceid-overlay-container.fade-out {
+          animation: fadeOut 0.3s ease-out;
+        }
+
+        .neofaceid-overlay-content {
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+          justify-content: center;
+          gap: 24px;
+          pointer-events: auto;
+        }
+
+        .neofaceid-logo-wrapper {
+          position: relative;
+          width: 120px;
+          height: 120px;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+        }
+
+        .neofaceid-logo {
+          width: 80px;
+          height: 80px;
+          object-fit: contain;
+          filter: drop-shadow(0 4px 12px rgba(124, 58, 237, 0.3));
+        }
+
+        .neofaceid-logo.pulsing {
+          animation: pulse 2s ease-in-out infinite;
+        }
+
+        .neofaceid-status-icon {
+          position: absolute;
+          inset: 0;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+        }
+
+        .neofaceid-success-icon {
+          width: 60px;
+          height: 60px;
+          color: #10b981;
+          animation: scaleIn 0.6s ease-out;
+        }
+
+        .neofaceid-success-icon svg circle {
+          stroke-dasharray: 100;
+          stroke-dashoffset: 100;
+          animation: checkmark 0.6s ease-out 0.2s forwards;
+        }
+
+        .neofaceid-error-icon {
+          width: 60px;
+          height: 60px;
+          color: #ef4444;
+          animation: errorShake 0.5s ease-out, scaleIn 0.4s ease-out;
+        }
+
+        /* Responsive */
+        @media (max-width: 640px) {
+          .neofaceid-logo-wrapper {
+            width: 100px;
+            height: 100px;
+          }
+
+          .neofaceid-logo {
+            width: 70px;
+            height: 70px;
+          }
+        }
+      ` }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: `neofaceid-overlay-container ${!isVisible ? "fade-out" : ""}`, children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "neofaceid-overlay-content", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "neofaceid-logo-wrapper", children: [
+      (status === "preparing" || status === "verifying") && /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+        "img",
+        {
+          src: "/public/logo-icone-no-backgorund.png",
+          alt: "NeoFaceId",
+          className: `neofaceid-logo ${status === "verifying" ? "pulsing" : ""}`,
+          onError: (e) => {
+            var _a;
+            const img = e.target;
+            img.style.display = "none";
+            const fallback = document.createElement("div");
+            fallback.innerHTML = `
+                      <svg width="80" height="80" viewBox="0 0 80 80" fill="none" xmlns="http://www.w3.org/2000/svg">
+                        <circle cx="40" cy="40" r="35" fill="#7c3aed" opacity="0.2"/>
+                        <path d="M40 20 L40 60 M20 40 L60 40" stroke="#7c3aed" stroke-width="4" stroke-linecap="round"/>
+                      </svg>
+                    `;
+            fallback.style.cssText = "width: 80px; height: 80px; display: flex; align-items: center; justify-content: center;";
+            (_a = img.parentElement) == null ? void 0 : _a.appendChild(fallback);
+          }
+        }
+      ) }),
+      status === "success" && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "neofaceid-status-icon", children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        "svg",
+        {
+          className: "neofaceid-success-icon",
+          viewBox: "0 0 60 60",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "circle",
+              {
+                cx: "30",
+                cy: "30",
+                r: "28",
+                stroke: "currentColor",
+                strokeWidth: "3",
+                fill: "none"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "path",
+              {
+                d: "M15 30 L25 40 L45 20",
+                stroke: "currentColor",
+                strokeWidth: "3",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                fill: "none"
+              }
+            )
+          ]
+        }
+      ) }),
+      status === "error" && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "neofaceid-status-icon", children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        "svg",
+        {
+          className: "neofaceid-error-icon",
+          viewBox: "0 0 60 60",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "circle",
+              {
+                cx: "30",
+                cy: "30",
+                r: "28",
+                stroke: "currentColor",
+                strokeWidth: "3",
+                fill: "none"
+              }
+            ),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              "path",
+              {
+                d: "M20 20 L40 40 M40 20 L20 40",
+                stroke: "currentColor",
+                strokeWidth: "3",
+                strokeLinecap: "round"
+              }
+            )
+          ]
+        }
+      ) })
+    ] }) }) })
+  ] });
+}
+class BiometricStatusOverlay {
+  constructor() {
+    __publicField(this, "container", null);
+    __publicField(this, "root", null);
+    __publicField(this, "currentStatus", "preparing");
+  }
+  /**
+   * Cria e exibe o overlay
+   */
+  show(status = "preparing") {
+    if (this.container) {
+      this.updateStatus(status);
+      return;
+    }
+    this.container = document.createElement("div");
+    this.container.id = "neofaceid-status-overlay";
+    document.body.appendChild(this.container);
+    this.root = createRoot(this.container);
+    this.currentStatus = status;
+    this.render();
+  }
+  /**
+   * Atualiza o status do overlay
+   */
+  updateStatus(status) {
+    this.currentStatus = status;
+    if (this.root) {
+      this.render();
+    }
+  }
+  /**
+   * Fecha e remove o overlay
+   */
+  close() {
+    if (this.container) {
+      if (this.root) {
+        this.root.render(
+          /* @__PURE__ */ jsxRuntimeExports.jsx(
+            BiometricStatusOverlayComponent,
+            {
+              status: this.currentStatus,
+              onClose: () => {
+                if (this.container && document.body.contains(this.container)) {
+                  document.body.removeChild(this.container);
+                }
+                this.container = null;
+                this.root = null;
+              }
+            }
+          )
+        );
+      }
+      setTimeout(() => {
+        if (this.container && document.body.contains(this.container)) {
+          document.body.removeChild(this.container);
+        }
+        this.container = null;
+        this.root = null;
+      }, 300);
+    }
+  }
+  /**
+   * Renderiza o componente
+   */
+  render() {
+    if (!this.root || !this.container)
+      return;
+    this.root.render(
+      /* @__PURE__ */ jsxRuntimeExports.jsx(BiometricStatusOverlayComponent, { status: this.currentStatus, onClose: () => this.close() })
+    );
+  }
+}
+function FallbackPromptComponent({
+  error,
+  onRetry,
+  onCredentials,
+  onCancel
+}) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("style", { children: `
+        @keyframes slideUp {
+          from {
+            opacity: 0;
+            transform: translateY(20px);
+          }
+          to {
+            opacity: 1;
+            transform: translateY(0);
+          }
+        }
+
+        @keyframes fadeIn {
+          from { opacity: 0; }
+          to { opacity: 1; }
+        }
+
+        .neofaceid-fallback-overlay {
+          position: fixed;
+          inset: 0;
+          background: rgba(0, 0, 0, 0.6);
+          backdrop-filter: blur(8px);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          z-index: 10001;
+          padding: 20px;
+          animation: fadeIn 0.3s ease-out;
+        }
+
+        .neofaceid-fallback-prompt {
+          background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+          border-radius: 20px;
+          padding: 32px;
+          max-width: 400px;
+          width: 100%;
+          box-shadow: 0 24px 48px rgba(0, 0, 0, 0.4), 0 0 0 1px rgba(255, 255, 255, 0.1);
+          animation: slideUp 0.4s ease-out;
+          text-align: center;
+        }
+
+        .neofaceid-fallback-icon {
+          width: 64px;
+          height: 64px;
+          margin: 0 auto 20px;
+          color: #ef4444;
+          animation: scaleIn 0.4s ease-out;
+        }
+
+        @keyframes scaleIn {
+          0% {
+            transform: scale(0);
+            opacity: 0;
+          }
+          50% {
+            transform: scale(1.1);
+          }
+          100% {
+            transform: scale(1);
+            opacity: 1;
+          }
+        }
+
+        .neofaceid-fallback-title {
+          font-size: 22px;
+          font-weight: 700;
+          color: white;
+          margin: 0 0 12px 0;
+        }
+
+        .neofaceid-fallback-message {
+          font-size: 15px;
+          color: rgba(255, 255, 255, 0.7);
+          margin: 0 0 28px 0;
+          line-height: 1.5;
+        }
+
+        .neofaceid-fallback-actions {
+          display: flex;
+          flex-direction: column;
+          gap: 12px;
+        }
+
+        .neofaceid-fallback-button {
+          padding: 14px 24px;
+          border-radius: 12px;
+          border: none;
+          font-size: 16px;
+          font-weight: 600;
+          cursor: pointer;
+          transition: all 0.2s;
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        }
+
+        .neofaceid-fallback-button-primary {
+          background: linear-gradient(135deg, #7c3aed 0%, #6d28d9 100%);
+          color: white;
+          box-shadow: 0 4px 16px rgba(124, 58, 237, 0.3);
+        }
+
+        .neofaceid-fallback-button-primary:hover {
+          transform: translateY(-2px);
+          box-shadow: 0 8px 24px rgba(124, 58, 237, 0.4);
+        }
+
+        .neofaceid-fallback-button-primary:active {
+          transform: translateY(0);
+        }
+
+        .neofaceid-fallback-button-secondary {
+          background: rgba(255, 255, 255, 0.1);
+          color: white;
+          border: 1px solid rgba(255, 255, 255, 0.2);
+        }
+
+        .neofaceid-fallback-button-secondary:hover {
+          background: rgba(255, 255, 255, 0.15);
+          border-color: rgba(255, 255, 255, 0.3);
+        }
+
+        .neofaceid-fallback-button-ghost {
+          background: transparent;
+          color: rgba(255, 255, 255, 0.7);
+          padding: 10px;
+        }
+
+        .neofaceid-fallback-button-ghost:hover {
+          color: white;
+          background: rgba(255, 255, 255, 0.05);
+        }
+
+        @media (max-width: 640px) {
+          .neofaceid-fallback-prompt {
+            padding: 24px;
+            border-radius: 16px;
+          }
+
+          .neofaceid-fallback-title {
+            font-size: 20px;
+          }
+        }
+      ` }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "neofaceid-fallback-overlay", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "neofaceid-fallback-prompt", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "neofaceid-fallback-icon", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("svg", { viewBox: "0 0 64 64", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx("circle", { cx: "32", cy: "32", r: "30", stroke: "currentColor", strokeWidth: "3", fill: "none" }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "path",
+          {
+            d: "M20 20 L44 44 M44 20 L20 44",
+            stroke: "currentColor",
+            strokeWidth: "3",
+            strokeLinecap: "round"
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("h3", { className: "neofaceid-fallback-title", children: "Não foi possível reconhecer" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("p", { className: "neofaceid-fallback-message", children: (error == null ? void 0 : error.message) || "Não conseguimos reconhecer sua face. Tente novamente ou use email e senha." }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "neofaceid-fallback-actions", children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            type: "button",
+            className: "neofaceid-fallback-button neofaceid-fallback-button-primary",
+            onClick: onRetry,
+            children: "Tentar Novamente"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            type: "button",
+            className: "neofaceid-fallback-button neofaceid-fallback-button-secondary",
+            onClick: onCredentials,
+            children: "Entrar com Email e Senha"
+          }
+        ),
+        onCancel && /* @__PURE__ */ jsxRuntimeExports.jsx(
+          "button",
+          {
+            type: "button",
+            className: "neofaceid-fallback-button neofaceid-fallback-button-ghost",
+            onClick: onCancel,
+            children: "Cancelar"
+          }
+        )
+      ] })
+    ] }) })
+  ] });
+}
+class FallbackPrompt {
+  constructor() {
+    __publicField(this, "container", null);
+    __publicField(this, "root", null);
+  }
+  /**
+   * Exibe o prompt de fallback
+   */
+  show(error, onRetry, onCredentials, onCancel) {
+    if (this.container) {
+      return;
+    }
+    this.container = document.createElement("div");
+    this.container.id = "neofaceid-fallback-prompt";
+    document.body.appendChild(this.container);
+    this.root = createRoot(this.container);
+    this.render(error, onRetry, onCredentials, onCancel);
+  }
+  /**
+   * Fecha o prompt
+   */
+  close() {
+    if (this.container && document.body.contains(this.container)) {
+      if (this.root) {
+        this.root.unmount();
+      }
+      document.body.removeChild(this.container);
+      this.container = null;
+      this.root = null;
+    }
+  }
+  /**
+   * Renderiza o componente
+   */
+  render(error, onRetry, onCredentials, onCancel) {
+    if (!this.root || !this.container)
+      return;
+    this.root.render(
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        FallbackPromptComponent,
+        {
+          error,
+          onRetry: () => {
+            this.close();
+            onRetry();
+          },
+          onCredentials: () => {
+            this.close();
+            onCredentials();
+          },
+          onCancel: () => {
+            this.close();
+            onCancel == null ? void 0 : onCancel();
+          }
+        }
+      )
+    );
+  }
+}
+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.addStyles();
+    this.modalElement = document.createElement("div");
+    this.modalElement.className = "neoface-email-password-modal";
+    this.modalElement.innerHTML = `
+      <div class="neoface-email-modal-overlay">
+        <div class="neoface-email-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" class="neoface-email-submit-btn">Entrar</button>
+          </form>
+          <button class="neoface-email-cancel-btn">Cancelar</button>
+          
+          <!-- Branding -->
+          <div class="neoface-email-branding">
+            <img src="/public/logo-icone-no-backgorund.png" alt="NeoFaceId" class="neoface-email-brand-logo" onerror="this.style.display='none'" />
+            <span>NeoFaceId by</span>
+            <span class="neoface-email-brand-name">OCTA</span>
+          </div>
+        </div>
+      </div>
+    `;
+    const form = this.modalElement.querySelector("#email-password-form");
+    form.addEventListener("submit", this.handleSubmit.bind(this));
+    const cancelButton = this.modalElement.querySelector(
+      ".neoface-email-cancel-btn"
+    );
+    cancelButton.addEventListener("click", this.close.bind(this));
+  }
+  addStyles() {
+    const styleId = "neoface-email-password-modal-styles";
+    const existingStyles = document.getElementById(styleId);
+    if (existingStyles) {
+      return;
+    }
+    const style = document.createElement("style");
+    style.id = styleId;
+    style.textContent = `
+      .neoface-email-password-modal {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        z-index: 10002;
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      }
+
+      .neoface-email-modal-overlay {
+        position: absolute;
+        inset: 0;
+        background: rgba(0, 0, 0, 0.6);
+        backdrop-filter: blur(8px);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 20px;
+        animation: fadeIn 0.3s ease-out;
+      }
+
+      @keyframes fadeIn {
+        from { opacity: 0; }
+        to { opacity: 1; }
+      }
+
+      @keyframes slideUp {
+        from {
+          opacity: 0;
+          transform: translateY(20px);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0);
+        }
+      }
+
+      .neoface-email-modal-content {
+        background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+        border-radius: 20px;
+        padding: 32px;
+        max-width: 400px;
+        width: 100%;
+        box-shadow: 0 24px 48px rgba(0, 0, 0, 0.4), 0 0 0 1px rgba(255, 255, 255, 0.1);
+        animation: slideUp 0.4s ease-out;
+      }
+
+      .neoface-email-modal-content h2 {
+        font-size: 24px;
+        font-weight: 700;
+        color: white;
+        margin: 0 0 12px 0;
+        text-align: center;
+      }
+
+      .neoface-email-modal-content p {
+        font-size: 15px;
+        color: rgba(255, 255, 255, 0.7);
+        margin: 0 0 24px 0;
+        text-align: center;
+        line-height: 1.5;
+      }
+
+      .neoface-email-modal-content form {
+        display: flex;
+        flex-direction: column;
+        gap: 16px;
+        margin-bottom: 16px;
+      }
+
+      .neoface-email-modal-content input {
+        width: 100%;
+        padding: 14px 16px;
+        border: 2px solid rgba(255, 255, 255, 0.2);
+        border-radius: 12px;
+        font-size: 15px;
+        background: rgba(255, 255, 255, 0.1);
+        color: white;
+        font-family: inherit;
+        transition: all 0.2s;
+        box-sizing: border-box;
+      }
+
+      .neoface-email-modal-content input::placeholder {
+        color: rgba(255, 255, 255, 0.5);
+      }
+
+      .neoface-email-modal-content input:focus {
+        outline: none;
+        border-color: #7c3aed;
+        box-shadow: 0 0 0 3px rgba(124, 58, 237, 0.2);
+        background: rgba(255, 255, 255, 0.15);
+      }
+
+      .neoface-email-submit-btn {
+        width: 100%;
+        padding: 14px 24px;
+        border-radius: 12px;
+        border: none;
+        background: linear-gradient(135deg, #7c3aed 0%, #6d28d9 100%);
+        color: white;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s;
+        box-shadow: 0 4px 16px rgba(124, 58, 237, 0.3);
+        font-family: inherit;
+      }
+
+      .neoface-email-submit-btn:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 8px 24px rgba(124, 58, 237, 0.4);
+      }
+
+      .neoface-email-submit-btn:active {
+        transform: translateY(0);
+      }
+
+      .neoface-email-submit-btn:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+        transform: none;
+      }
+
+      .neoface-email-cancel-btn {
+        width: 100%;
+        padding: 12px 24px;
+        border-radius: 12px;
+        border: 1px solid rgba(255, 255, 255, 0.2);
+        background: transparent;
+        color: rgba(255, 255, 255, 0.7);
+        font-size: 15px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s;
+        font-family: inherit;
+      }
+
+      .neoface-email-cancel-btn:hover {
+        background: rgba(255, 255, 255, 0.1);
+        color: white;
+        border-color: rgba(255, 255, 255, 0.3);
+      }
+
+      .neoface-email-branding {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        margin-top: 32px;
+        padding-top: 24px;
+        border-top: 1px solid rgba(255, 255, 255, 0.1);
+        font-size: 13px;
+        color: rgba(255, 255, 255, 0.5);
+      }
+
+      .neoface-email-brand-logo {
+        height: 20px;
+        width: auto;
+      }
+
+      .neoface-email-brand-name {
+        font-weight: 600;
+        font-family: 'SF Pro Display', -apple-system, system-ui, sans-serif;
+        color: #ffffff;
+        letter-spacing: 0.3px;
+      }
+
+      @media (max-width: 640px) {
+        .neoface-email-modal-content {
+          padding: 24px;
+          border-radius: 16px;
+        }
+
+        .neoface-email-modal-content h2 {
+          font-size: 20px;
+        }
+      }
+    `;
+    document.head.appendChild(style);
+  }
+  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);
+    }
+  }
+}
+const MAX_ATTEMPTS = 3;
+const RETRY_DELAY = 500;
+async function detectFaceContinuously(video, minDetectionTime = 3e3, detectionInterval = 200) {
+  return new Promise((resolve) => {
+    let faceDetectedCount = 0;
+    let totalChecks = 0;
+    const requiredChecks = Math.ceil(minDetectionTime / detectionInterval);
+    const minSuccessRate = 0.6;
+    let timeoutId = null;
+    let isResolved = false;
+    const finish = (success) => {
+      if (isResolved)
+        return;
+      isResolved = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve(success);
+    };
+    const checkFace = async () => {
+      if (isResolved)
+        return;
+      try {
+        const detection = await faceapi.detectSingleFace(
+          video,
+          new faceapi.TinyFaceDetectorOptions({ inputSize: 160, scoreThreshold: 0.4 })
+        );
+        totalChecks++;
+        if (detection) {
+          faceDetectedCount++;
+        }
+        if (totalChecks >= requiredChecks) {
+          const successRate = faceDetectedCount / totalChecks;
+          finish(successRate >= minSuccessRate);
+          return;
+        }
+        timeoutId = window.setTimeout(checkFace, detectionInterval);
+      } catch (error) {
+        totalChecks++;
+        if (totalChecks >= requiredChecks) {
+          const successRate = faceDetectedCount / totalChecks;
+          finish(successRate >= minSuccessRate);
+        } else {
+          timeoutId = window.setTimeout(checkFace, detectionInterval);
+        }
+      }
+    };
+    const safetyTimeout = window.setTimeout(() => {
+      if (!isResolved) {
+        const successRate = totalChecks > 0 ? faceDetectedCount / totalChecks : 0;
+        finish(successRate >= minSuccessRate);
+      }
+    }, minDetectionTime + 1e3);
+    timeoutId = window.setTimeout(() => {
+      checkFace();
+      clearTimeout(safetyTimeout);
+    }, detectionInterval);
+  });
+}
+async function attemptLogin(applicationToken, overlay) {
+  overlay.updateStatus("verifying");
+  const video = document.createElement("video");
+  video.style.position = "fixed";
+  video.style.top = "-9999px";
+  video.style.left = "-9999px";
+  video.style.width = "1px";
+  video.style.height = "1px";
+  video.style.opacity = "0";
+  video.setAttribute("autoplay", "");
+  video.setAttribute("muted", "");
+  video.setAttribute("playsinline", "");
+  document.body.appendChild(video);
+  let stream = null;
+  try {
+    stream = await navigator.mediaDevices.getUserMedia({
+      video: {
+        width: { ideal: 640 },
+        height: { ideal: 480 },
+        facingMode: "user"
+      },
+      audio: false
+    });
+    video.srcObject = stream;
+    await video.play();
+    await new Promise((resolve) => {
+      if (video.readyState >= 2) {
+        resolve(void 0);
+      } else {
+        video.onloadedmetadata = () => resolve(void 0);
+      }
+    });
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const faceDetected = await detectFaceContinuously(video, 3e3);
+    if (!faceDetected) {
+      if (stream) {
+        stream.getTracks().forEach((track) => track.stop());
+      }
+      if (video.parentElement) {
+        video.parentElement.removeChild(video);
+      }
+      throw new NeoFaceError("Rosto não detectado. Posicione seu rosto na frente da câmera.", ErrorType.VALIDATION_ERROR);
+    }
+    const canvas = document.createElement("canvas");
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      if (stream) {
+        stream.getTracks().forEach((track) => track.stop());
+      }
+      if (video.parentElement) {
+        video.parentElement.removeChild(video);
+      }
+      throw new NeoFaceError("Erro ao capturar imagem", ErrorType.CAPTURE_ERROR);
+    }
+    ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+    if (stream) {
+      stream.getTracks().forEach((track) => track.stop());
+    }
+    if (video.parentElement) {
+      video.parentElement.removeChild(video);
+    }
+    const imageBlob = await new Promise((resolve, reject) => {
+      canvas.toBlob(
+        (blob) => {
+          canvas.remove();
+          if (blob) {
+            resolve(blob);
+          } else {
+            reject(new Error("Failed to capture image"));
+          }
+        },
+        "image/jpeg",
+        0.85
+      );
+    });
+    const result = await loginWithBiometric$1(imageBlob, applicationToken);
+    if (!result.success) {
+      throw new NeoFaceError("Login falhou", ErrorType.LOGIN_FAILED);
+    }
+    return result;
+  } catch (error) {
+    if (stream) {
+      stream.getTracks().forEach((track) => track.stop());
+    }
+    if (video.parentElement) {
+      video.parentElement.removeChild(video);
+    }
+    if (error instanceof NeoFaceError) {
+      throw error;
+    }
+    throw new NeoFaceError(
+      error instanceof Error ? error.message : "Erro desconhecido",
+      ErrorType.UNKNOWN
+    );
+  }
+}
+async function executeBiometricLoginFlow(options) {
+  const { applicationToken, onSuccess, onError, onFallbackRequest, onCancel } = options;
+  const overlay = new BiometricStatusOverlay();
+  const fallbackPrompt = new FallbackPrompt();
+  let attempts = 0;
+  let lastError;
+  try {
+    const MODEL_URL = "https://cdn.jsdelivr.net/npm/@vladmandic/face-api/model";
+    await Promise.all([
+      faceapi.nets.tinyFaceDetector.loadFromUri(MODEL_URL),
+      faceapi.nets.faceLandmark68Net.loadFromUri(MODEL_URL)
+    ]);
+  } catch (error) {
+    console.warn("Face-api.js models not loaded, continuing without face detection");
+  }
+  overlay.show("preparing");
+  const tryLogin = async () => {
+    try {
+      attempts++;
+      const result = await attemptLogin(applicationToken, overlay);
+      overlay.updateStatus("success");
+      setTimeout(() => {
+        overlay.close();
+        onSuccess(result);
+      }, 800);
+    } catch (error) {
+      lastError = error instanceof NeoFaceError ? error : new NeoFaceError(
+        error instanceof Error ? error.message : "Erro desconhecido",
+        ErrorType.UNKNOWN
+      );
+      overlay.updateStatus("error");
+      if (attempts < MAX_ATTEMPTS) {
+        setTimeout(() => {
+          tryLogin();
+        }, RETRY_DELAY);
+      } else {
+        setTimeout(() => {
+          overlay.close();
+          fallbackPrompt.show(
+            lastError,
+            () => {
+              attempts = 0;
+              overlay.show("preparing");
+              setTimeout(() => tryLogin(), 500);
+            },
+            () => {
+              if (onFallbackRequest) {
+                onFallbackRequest();
+              } else {
+                onError(
+                  new NeoFaceError(
+                    "Por favor, use email e senha para fazer login",
+                    ErrorType.LOGIN_FAILED
+                  )
+                );
+              }
+            },
+            onCancel
+          );
+        }, 1e3);
+      }
+    }
+  };
+  setTimeout(() => {
+    tryLogin();
+  }, 300);
+}
+async function startFaceLogin(options) {
+  try {
+    const isValidToken = await validateToken(options.applicationToken);
+    if (!isValidToken) {
+      options.onError(new NeoFaceError("Token de aplicação inválido", ErrorType.INVALID_TOKEN));
+      return;
+    }
+    await executeBiometricLoginFlow({
+      applicationToken: options.applicationToken,
+      onSuccess: options.onSuccess,
+      onError: options.onError,
+      onFallbackRequest: options.onFallbackRequest || (() => {
+        const fallbackOptions = {
+          applicationToken: options.applicationToken,
+          onSuccess: options.onSuccess,
+          onError: options.onError,
+          title: "Login Alternativo",
+          subtitle: "Biometria não reconhecida. Por favor, informe email e senha."
+        };
+        const modal = new EmailPasswordModal(fallbackOptions);
+        modal.open();
+      }),
+      onCancel: options.onCancel
+    });
   } catch (error) {
     options.onError(
       new NeoFaceError(
@@ -4040,8 +5229,8 @@ const biometricDetection = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.
   initializeBiometricDetection,
   isAdvancedDetectionAvailable
 }, Symbol.toStringTag, { value: "Module" }));
-const VERSION = "1.2.0";
-const RELEASE_DATE = "2025-11-09";
+const VERSION = "1.4.0";
+const RELEASE_DATE = "2025-11-23";
 class OnboardingCaptureModal {
   constructor(options) {
     __publicField(this, "overlay", null);
@@ -4327,19 +5516,25 @@ function startBiometricRegistration(personData, applicationToken, callbacks, opt
   });
 }
 export {
-  BiometricCaptureModal,
+  BiometricCaptureModal$1 as BiometricCaptureModal,
   BiometricRegistrationModal,
+  BiometricStatusOverlay,
+  EmailPasswordModal,
   ErrorType,
   FaceCaptureModal,
+  FallbackPrompt,
   NeoFaceError,
   RELEASE_DATE,
   VERSION,
   biometricLogin,
   biometricLoginWithFallback,
+  completeOnboarding,
+  completeOnboardingWithData,
   detectBiometricType,
+  identifyPerson,
   initializeBiometricDetection,
   isAdvancedDetectionAvailable,
-  loginWithBiometric,
+  loginWithBiometric$1 as loginWithBiometric,
   recognize,
   recognizeBiometric,
   recognizeByPurpose,
@@ -4352,6 +5547,7 @@ export {
   startFaceLogin,
   startHandLogin,
   startOnboarding,
+  validateOnboardingToken,
   validateToken
 };
 //# sourceMappingURL=neoface-id-sdk.es.js.map