@metodokorexmk/tracking 1.0.0 → 1.2.0

package/dist/index.d.ts

@@ -1,17 +1,17 @@
 /**
- * Tipos e interfaces compartidas para @metodokorexmk/tracking
+ * Shared types and interfaces for @metodokorexmk/tracking.
  */
 /**
- * Configuración principal del tracking.
- * Se pasa a `initGA()` para inicializar el sistema.
+ * Main tracking configuration.
+ * Passed to `initGA()` to initialize the tracking system.
  */
 interface TrackingConfig {
-    /** ID de Google Analytics 4 (ej: 'G-XXXXXXX') */
+    /** Google Analytics 4 Measurement ID (e.g., 'G-XXXXXXX') */
     trackingId?: string;
     /**
-     * Función personalizada para resolver el GA Tracking ID dinámicamente.
-     * Recibe la URL actual y debe devolver el ID correspondiente.
-     * Si se proporciona, tiene prioridad sobre `trackingId`.
+     * Custom resolver for the GA Tracking ID.
+     * Receives the current path and must return the corresponding ID.
+     * Takes priority over `trackingId` when provided.
      *
      * @example
      * ```ts
@@ -22,40 +22,40 @@ interface TrackingConfig {
      * ```
      */
     resolveTrackingId?: (currentPath: string) => string;
-    /** ID de Google Tag Manager (ej: 'GTM-XXXXXXX'). Si se proporciona, se inyecta GTM automáticamente. */
+    /** Google Tag Manager container ID (e.g., 'GTM-XXXXXXX'). If provided, GTM is injected automatically. */
     gtmId?: string;
-    /** Habilitar anonimización de IP en GA4 */
+    /** Enable IP anonymization in GA4 */
     anonymizeIp?: boolean;
-    /** Modo debug: imprime eventos en consola */
+    /** Debug mode: logs events to the console */
     debug?: boolean;
 }
 /**
- * Configuración del LandingTracker (orquestador de sesión).
+ * LandingTracker configuration (session orchestrator).
  */
 interface LandingTrackerConfig {
-    /** Ruta de la landing page (ej: '/kin', '/racha') */
+    /** Landing page path (e.g., '/kin', '/racha') */
     pagePath: string;
-    /** Nombre legible de la landing (ej: 'Kin Landing Page') */
+    /** Human-readable landing page name (e.g., 'Kin Landing Page') */
     pageName: string;
-    /** ID de Google Tag Manager (opcional) */
+    /** Google Tag Manager container ID (optional) */
     gtmId?: string;
-    /** Habilitar tracking de scroll (milestones 25/50/75/100%). Default: true */
+    /** Enable scroll tracking (milestones 25/50/75/100%). Default: true */
     enableScrollTracking?: boolean;
-    /** Habilitar tracking automático de clicks en CTAs. Default: true */
+    /** Enable automatic CTA click tracking. Default: true */
     enableCTATracking?: boolean;
-    /** Habilitar tracking de tiempo en página. Default: true */
+    /** Enable page dwell time tracking. Default: true */
     enableTimeTracking?: boolean;
-    /** Habilitar tracking de tiempo por sección (IntersectionObserver). Default: true */
+    /** Enable per-section dwell time via IntersectionObserver. Default: true */
     enableSectionTracking?: boolean;
-    /** Habilitar auto-tracking de formularios. Default: true */
+    /** Enable automatic form interaction tracking. Default: true */
     enableFormTracking?: boolean;
-    /** Habilitar heatmap de clicks (coordenadas X/Y). Default: false */
+    /** Enable click heatmap (X/Y coordinates). Default: false */
     enableHeatmap?: boolean;
-    /** Sufijo personalizado para eventos (ej: '_kin' para 'cta_click_kin'). Default: '' */
+    /** Custom event suffix (e.g., '_kin' produces 'cta_click_kin'). Default: '' */
     eventSuffix?: string;
 }
 /**
- * Parámetros UTM capturados de la URL.
+ * UTM parameters captured from the URL.
  */
 interface UTMParams {
     utm_source?: string;
@@ -65,7 +65,7 @@ interface UTMParams {
     utm_content?: string;
 }
 /**
- * Datos de identificación del visitante capturados.
+ * Captured visitor identification data.
  */
 interface VisitorData {
     userId?: string;
@@ -75,20 +75,20 @@ interface VisitorData {
     entryUrl: string;
 }
 /**
- * Estadísticas de reproducción de un video.
- * Compartido entre todos los adaptadores (Wistia, Voomly, HTML5).
+ * Video playback statistics.
+ * Shared across all adapters (Wistia, Voomly, HTML5).
  */
 interface VideoStats {
-    /** Tiempo total reproducido en segundos */
+    /** Total time watched in seconds */
     timeWatched: number;
-    /** Si el video fue completado (≥90-95%) */
+    /** Whether the video was completed (>=90-95%) */
     completed: boolean;
-    /** Timestamp de la última actualización */
+    /** Timestamp of the last stats update */
     lastUpdate: number;
 }
 /**
- * Estado interno detallado de tracking de un video.
- * Usado internamente por VideoTracker.
+ * Detailed internal video tracking state.
+ * Used internally by VideoTracker.
  */
 interface VideoTrackingState {
     videoId: string;
@@ -111,41 +111,41 @@ interface VideoTrackingState {
     playbackSpeed: number;
 }
 /**
- * Opciones para los hooks de video en React.
+ * Options for React video tracking hooks.
  */
 interface UseVideoTrackingOptions {
-    /** ID único del video */
+    /** Unique video identifier */
     videoId: string;
-    /** Referencia al elemento <video> HTML (solo para HTML5) */
+    /** Reference to the HTML <video> element (HTML5 only) */
     videoElement?: HTMLVideoElement | null;
-    /** Callback cuando el video se completa */
+    /** Callback when the video completes */
     onComplete?: () => void;
-    /** Callback en milestones de progreso (25, 50, 75) */
+    /** Callback on progress milestones (25, 50, 75) */
     onProgress?: (percentage: number) => void;
 }
 /**
- * Callback para actualizaciones de video.
+ * Callback for video stats updates.
  */
 type VideoUpdateCallback = (stats: VideoStats) => void;
 /**
- * Objeto retornado por los adaptadores de video (Wistia, Voomly).
+ * Handle returned by video adapters (Wistia, Voomly, HTML5).
  */
 interface VideoTrackerHandle {
-    /** Obtener estadísticas actuales */
+    /** Get current playback stats */
     getStats: () => VideoStats;
-    /** Registrar callback de actualización. Retorna función para desregistrar. */
+    /** Register an update callback. Returns an unsubscribe function. */
     onUpdate: (cb: VideoUpdateCallback) => () => void;
-    /** Detener tracking y limpiar listeners */
+    /** Stop tracking and clean up listeners */
     stop: () => void;
 }
 /**
- * Payload genérico de un evento de tracking.
+ * Generic tracking event payload.
  */
 interface TrackingEventData {
     [key: string]: unknown;
 }
 /**
- * Datos de un click capturado para heatmap.
+ * Captured click data for heatmap visualization.
  */
 interface ClickData {
     x: number;
@@ -157,7 +157,7 @@ interface ClickData {
     viewportHeight: number;
 }
 /**
- * Resumen de sesión al salir de la página.
+ * Session summary emitted on page exit.
  */
 interface SessionSummary {
     duration: number;
@@ -168,19 +168,19 @@ interface SessionSummary {
     formInteractions: number;
 }
 /**
- * Configuración del cliente HTTP para persistencia.
- * Se pasa a `initTrackingAPI()`.
+ * HTTP client configuration for the persistence layer.
+ * Passed to `initTrackingAPI()`.
  */
 interface TrackingAPIConfig {
-    /** URL base del API (ej: 'https://api.korex.com/api/v1') */
+    /** API base URL (e.g., 'https://api.korex.com/api/v1') */
     baseUrl: string;
-    /** Función que retorna el token de autenticación (ej: de localStorage) */
+    /** Function that returns the auth token (e.g., from localStorage) */
     getAuthToken?: () => string | null;
-    /** Headers adicionales para cada petición */
+    /** Additional headers for each request */
     getCustomHeaders?: () => Record<string, string>;
 }
 /**
- * Modelo de tracking lead del backend.
+ * Backend tracking lead model.
  */
 interface TrackingLead {
     id: number;
@@ -210,7 +210,7 @@ interface TrackingLead {
     dwellTime?: number;
 }
 /**
- * Datos procesados de lead con tracking (respuesta de GET /leads/{id}/with-tracking).
+ * Processed lead data with tracking info (response from GET /leads/{id}/with-tracking).
  */
 interface LeadTrackingData {
     videoVisto: boolean;
@@ -226,7 +226,7 @@ interface LeadTrackingData {
     dwellTime?: number;
 }
 /**
- * Datos de formulario para enviar con un lead.
+ * Form data submitted with a lead.
  */
 interface LeadFormData {
     nombre: string;
@@ -236,11 +236,15 @@ interface LeadFormData {
     [key: string]: unknown;
 }
 /**
- * Parámetros extraídos de la URL para detección de origen.
+ * URL parameters extracted for lead origin detection.
  */
 interface UrlParams {
     userId: string;
     idCampana: string;
+    /** Meta Ads: ad set identifier (adset_id) — ad traceability */
+    adsetId: string;
+    /** Meta Ads: individual ad identifier (ad_id) — ad traceability */
+    adId: string;
     utmContent: string;
     fbclid: string;
     nombreNetworker: string;
@@ -251,11 +255,14 @@ interface UrlParams {
     utmSource?: string;
     utmMedium?: string;
     utmCampaign?: string;
+    /** Spelling correction of leadCampaing */
+    leadCampaign?: string;
+    /** @deprecated Use leadCampaign instead */
     leadCampaing?: string;
     isOrganico?: boolean;
 }
 /**
- * Resultado de la detección de origen de un lead.
+ * Result of lead origin detection.
  */
 interface LeadOrigin {
     type: 'facebook' | 'organic';
@@ -264,7 +271,7 @@ interface LeadOrigin {
     hasCampaign: boolean;
 }
 /**
- * Respuesta del API al crear/enviar un tracking lead.
+ * API response when creating/submitting a tracking lead.
  */
 interface TrackingLeadResponse {
     colaboradorAsignado?: {
@@ -277,7 +284,7 @@ interface TrackingLeadResponse {
     [key: string]: unknown;
 }
 /**
- * Respuesta procesada de submitTrackingLead.
+ * Processed response from submitTrackingLead.
  */
 interface SubmitTrackingLeadResponse {
     ok: boolean;
@@ -285,7 +292,7 @@ interface SubmitTrackingLeadResponse {
     data: TrackingLeadResponse | null;
 }
 /**
- * Opciones adicionales al construir el body de la petición de lead.
+ * Additional options for building the lead request body.
  */
 interface BuildRequestBodyOptions {
     nameForm?: string;
@@ -298,16 +305,16 @@ interface BuildRequestBodyOptions {
     additionalFields?: Record<string, unknown>;
 }
 /**
- * Configuración del DwellTimeTracker.
+ * DwellTimeTracker configuration.
  */
 interface DwellTimeConfig {
-    /** ID del tracking data en el backend */
+    /** Backend tracking data ID */
     trackingDataId: number | string;
-    /** Habilitar tracking (default: true) */
+    /** Enable tracking (default: true) */
     enabled?: boolean;
-    /** Callback al enviar exitosamente */
+    /** Callback on successful send */
     onSuccess?: () => void;
-    /** Callback en caso de error */
+    /** Callback on error */
     onError?: (error: Error) => void;
 }
 declare global {
@@ -322,26 +329,25 @@ declare global {
 }
 
 /**
- * Core de Google Analytics 4
- * Inicialización, tracking de eventos y captura de datos del visitante.
- * Desacoplado de cualquier framework (Next.js, React, etc.)
+ * Google Analytics 4 core module.
+ * Initialization, event tracking, and visitor data capture.
+ * Framework-agnostic (no Next.js, React, etc. dependency).
  */
 
 /**
- * Obtiene el GA Tracking ID actual.
- * Si se configuró un `resolveTrackingId`, lo usa dinámicamente.
- * Si no, usa el `trackingId` fijo de la config.
+ * Returns the current GA Tracking ID.
+ * Uses `resolveTrackingId` dynamically if configured, otherwise falls back to the static `trackingId`.
  */
 declare const getGATrackingId: () => string;
 /**
- * Inicializa Google Analytics con la configuración proporcionada.
+ * Initializes Google Analytics with the provided configuration.
  *
  * @example
  * ```ts
- * // Con ID fijo
+ * // With a fixed ID
  * initGA({ trackingId: 'G-XXXXXXX' })
  *
- * // Con resolución dinámica
+ * // With dynamic resolution
  * initGA({
  *   resolveTrackingId: (path) => {
  *     if (path.startsWith('/kin')) return 'G-KIN-ID'
@@ -352,70 +358,70 @@ declare const getGATrackingId: () => string;
  */
 declare const initGA: (config?: TrackingConfig) => void;
 /**
- * Reinicializa GA con un nuevo Tracking ID.
- * Útil cuando el ID cambia dinámicamente (ej. login del usuario).
+ * Reinitializes GA with a new Tracking ID.
+ * Useful when the ID changes dynamically (e.g., after user login).
  */
 declare const reinitGA: (newTrackingId: string) => void;
 /**
- * Verificar si GA está inicializado
+ * Returns whether GA has been initialized.
  */
 declare const isGAInitialized: () => boolean;
 /**
- * Extrae los parámetros UTM de la URL actual.
+ * Extracts UTM parameters from the current URL.
  */
 declare const captureUTMParams: () => UTMParams | null;
 /**
- * Captura el `user_id` desde la URL (?user_id=xxx).
- * Lo cachea internamente para enviarlo en todos los eventos.
+ * Captures the `user_id` from the URL query string (?user_id=xxx).
+ * Caches it internally to include in all subsequent events.
  */
 declare const captureUserIdFromURL: () => string | null;
 /**
- * Resuelve el nombre del usuario desde múltiples fuentes.
- * Prioridad: URL > localStorage > null
+ * Resolves the user name from multiple sources.
+ * Priority: URL > in-memory cache > localStorage > null
  */
 declare const getUserName: () => string | null;
 /**
- * Obtiene el user_id cacheado.
+ * Returns the cached user_id.
  */
 declare const getUserId: () => string | null;
 /**
- * Establece manualmente el user_id (ej. después de login).
+ * Manually sets the user_id (e.g., after login).
  */
 declare const setUserId: (userId: string) => void;
 /**
- * Establece manualmente el user_name.
+ * Manually sets the user_name.
  */
 declare const setUserName: (userName: string) => void;
 /**
- * Envía un pageview a GA4.
- * Automáticamente incluye UTM params y user_id si están disponibles.
+ * Sends a pageview to GA4.
+ * Automatically includes UTM params and user_id if available.
  */
 declare const trackPageView: (path: string) => void;
 /**
- * Envía un evento personalizado a GA4.
- * Usa envío dual: `window.gtag()` + `ReactGA.event()`.
- * Siempre incluye `user_id` y `user_name` como parámetros.
+ * Sends a custom event to GA4.
+ * Uses dual dispatch: `window.gtag()` + `ReactGA.event()`.
+ * Always includes `user_id` and `user_name` as parameters.
  *
  * @example
  * ```ts
- * trackEvent('CTA', 'click', 'Botón Hero', undefined, { section: 'hero' })
+ * trackEvent('CTA', 'click', 'Hero Button', undefined, { section: 'hero' })
  * ```
  */
 declare const trackEvent: (category: string, action: string, label?: string, value?: number, additionalData?: TrackingEventData) => void;
 /**
- * Resetea el estado interno (útil para tests y re-inicialización).
+ * Resets all internal state (useful for tests and reinitialization).
  */
 declare const resetAnalytics: () => void;
 
 /**
- * Google Tag Manager — Carga e inyección vanilla (sin Next.js)
- * Proporciona pushToDataLayer e injectGTMScript.
+ * Google Tag Manager — Vanilla injection (no Next.js dependency).
+ * Provides pushToDataLayer and injectGTMScript.
  */
 /**
- * Inyecta el script de Google Tag Manager en el <head> del documento.
- * Equivalente al componente <Script> de Next.js, pero framework-agnostic.
+ * Injects the Google Tag Manager script into the document <head>.
+ * Framework-agnostic equivalent of Next.js <Script> component.
  *
- * @param gtmId - ID de GTM (ej: 'GTM-5GMQNFMN')
+ * @param gtmId - GTM container ID (e.g., 'GTM-5GMQNFMN')
  *
  * @example
  * ```ts
@@ -424,78 +430,78 @@ declare const resetAnalytics: () => void;
  */
 declare const injectGTMScript: (gtmId: string) => void;
 /**
- * Envía un evento al dataLayer de GTM.
+ * Pushes an event to the GTM dataLayer.
  *
- * @param eventName - Nombre del evento
- * @param data - Datos adicionales del evento
+ * @param eventName - Name of the event
+ * @param data - Additional event data
  *
  * @example
  * ```ts
  * pushToDataLayer('page_view', { page_path: '/kin' })
- * pushToDataLayer('cta_click', { button_text: 'Únete', section: 'hero' })
+ * pushToDataLayer('cta_click', { button_text: 'Join Now', section: 'hero' })
  * ```
  */
 declare const pushToDataLayer: (eventName: string, data?: Record<string, unknown>) => void;
 
 /**
- * VideoTracker — Tracking avanzado de video para GA4
- * Gestiona el estado de reproducción por video y emite eventos a Google Analytics.
- * Framework-agnostic (no requiere React).
+ * VideoTracker — Advanced video tracking for GA4.
+ * Manages per-video playback state and emits events to Google Analytics.
+ * Framework-agnostic (no React dependency).
  */
 
 declare class VideoTracker {
     private videos;
     private watchTimeIntervals;
     /**
-     * Inicializa el tracking para un video.
+     * Initializes tracking for a video.
      */
     initVideo(videoId: string): void;
     /**
-     * Tracking de evento play.
+     * Tracks a play event.
      */
     trackPlay(videoId: string, currentTime?: number): void;
     /**
-     * Tracking de evento pause.
+     * Tracks a pause event.
      */
     trackPause(videoId: string, currentTime: number, duration?: number): void;
     /**
-     * Tracking de evento seek (saltar en el timeline).
+     * Tracks a seek event (timeline jump).
      */
     trackSeek(videoId: string, fromTime: number, toTime: number): void;
     /**
-     * Tracking de progreso (milestones: 25%, 50%, 75%).
+     * Tracks progress milestones (25%, 50%, 75%).
      */
     trackProgress(videoId: string, percentage: number, currentTime: number): void;
     /**
-     * Tracking de completación del video (≥95%).
+     * Tracks video completion (>=95%).
      */
     trackComplete(videoId: string, totalDuration: number): void;
     /**
-     * Tracking de fin del video (evento ended nativo).
+     * Tracks video end (native ended event).
      */
     trackEnd(videoId: string): void;
     /**
-     * Tracking de cambio de velocidad de reproducción.
+     * Tracks playback speed change.
      */
     trackSpeedChange(videoId: string, speed: number): void;
     /**
-     * Tracking de pantalla completa.
+     * Tracks fullscreen toggle.
      */
     trackFullscreen(videoId: string, isFullscreen: boolean): void;
     /**
-     * Tracking de no interacción (el usuario está en la página pero no interactúa con el video).
+     * Tracks no interaction (user is on the page but not interacting with the video).
      */
     trackNoInteraction(videoId: string, timeOnPage: number): void;
     /**
-     * Obtiene el estado actual de un video.
+     * Returns the current state of a video.
      */
     getState(videoId: string): VideoTrackingState | undefined;
     /**
-     * Limpia el tracking de un video específico.
+     * Cleans up tracking for a specific video.
      */
     cleanup(videoId: string): void;
     /**
-     * Limpia todo el tracking.
+     * Cleans up all video tracking.
      */
     cleanupAll(): void;
     private getOrCreateState;
@@ -503,14 +509,14 @@ declare class VideoTracker {
     private stopWatchTimeTracking;
 }
 /**
- * Instancia singleton del VideoTracker.
- * Usar cuando se necesita una sola instancia global.
+ * Singleton VideoTracker instance.
+ * Use when a single global instance is needed.
  */
 declare const videoTracker: VideoTracker;
 
 /**
- * Funciones genéricas de tracking de eventos para GA4.
- * Cada función es una abstracción de `trackEvent()` con categoría y acción predefinidas.
+ * Generic GA4 event tracking functions.
+ * Each function wraps `trackEvent()` with a predefined category and action.
  */
 
 declare const trackCTAClick: (buttonName: string, section: string, additionalData?: TrackingEventData) => void;
@@ -529,17 +535,40 @@ declare const trackPricingCardClick: (productName: string, price: number | strin
 declare const trackContactClick: (method: string) => void;
 declare const trackShare: (platform: string, content: string) => void;
 declare const trackDownload: (fileName: string, fileType: string) => void;
+/**
+ * Tracks quiz start (funnel stage 5).
+ * The quiz serves as an implicit lead scoring mechanism.
+ */
+declare const trackQuizStart: (quizName: string) => void;
+/**
+ * Tracks an individual quiz answer.
+ */
+declare const trackQuizAnswer: (quizName: string, questionIndex: number, answer: string) => void;
+/**
+ * Tracks quiz completion (funnel stage 5).
+ */
+declare const trackQuizComplete: (quizName: string, totalQuestions?: number, score?: number) => void;
+/**
+ * Tracks a Thank You Page visit (funnel stage 6).
+ * Confirms the lead completed the funnel flow.
+ */
+declare const trackThankYouPageVisit: (source?: string) => void;
+/**
+ * Tracks a WhatsApp link click (funnel stage 7).
+ * Complements markWhatsAppSent() which marks post-hoc.
+ */
+declare const trackWhatsAppClick: (phoneNumber?: string, section?: string) => void;
 
 /**
- * Adaptador de video Wistia
- * Detecta automáticamente el SDK de Wistia y se enlaza a sus eventos.
+ * Wistia video adapter.
+ * Auto-detects the Wistia SDK and binds to its events.
  * Framework-agnostic.
  */
 
 /**
- * Inicia tracking de un video Wistia por su Media ID.
- * Detecta si el player es Wistia nativo o un <video> HTML5.
- * Retorna un handle con getStats(), onUpdate() y stop().
+ * Starts tracking a Wistia video by its Media ID.
+ * Detects whether to use the native Wistia player or an HTML5 <video> fallback.
+ * Returns a handle with getStats(), onUpdate(), and stop().
  *
  * @example
  * ```ts
@@ -547,59 +576,59 @@ declare const trackDownload: (fileName: string, fileType: string) => void;
  * tracker.onUpdate((stats) => {
  *   console.log(stats.timeWatched, stats.completed)
  * })
- * // Al desmontar:
+ * // On unmount:
  * tracker.stop()
  * ```
  */
 declare const trackWistiaByMediaId: (mediaId: string) => Promise<VideoTrackerHandle | null>;
 
 /**
- * Adaptador de video Voomly
- * Usa 3 estrategias complementarias para trackear videos embebidos de Voomly.
+ * Voomly video adapter.
+ * Uses 3 complementary strategies to track embedded Voomly videos.
  * Framework-agnostic.
  */
 
 /**
- * Inicia tracking de un video Voomly por su Embed ID.
- * Usa 3 estrategias complementarias:
- * 1. Scan periódico del DOM (cada 2s) buscando <video> dentro del embed
- * 2. Polling de respaldo (cada 1s) leyendo .currentTime
- * 3. Eventos globales de window (voomly:video:*)
+ * Starts tracking a Voomly video by its Embed ID.
+ * Uses 3 complementary strategies:
+ * 1. Periodic DOM scan (every 2s) searching for <video> inside the embed
+ * 2. Fallback polling (every 1s) reading .currentTime
+ * 3. Global window events (voomly:video:*)
  *
  * @example
  * ```ts
  * const tracker = await trackVoomlyByEmbedId('my-voomly-id')
  * tracker.onUpdate((stats) => console.log(stats))
- * // IMPORTANTE: llamar stop() al desmontar para evitar memory leaks
+ * // IMPORTANT: call stop() on unmount to prevent memory leaks
  * tracker.stop()
  * ```
  */
 declare const trackVoomlyByEmbedId: (embedId: string) => Promise<VideoTrackerHandle | null>;
 
 /**
- * Adaptador de video HTML5 nativo
- * Tracking puro de elementos <video> sin dependencia de React.
+ * Native HTML5 video adapter.
+ * Pure tracking for <video> elements with no React dependency.
  */
 
 /**
- * Inicia tracking de un elemento <video> HTML5 nativo.
- * Escucha eventos estándar del Video API del navegador.
+ * Starts tracking a native HTML5 <video> element.
+ * Listens to standard browser Video API events.
  *
  * @example
  * ```ts
  * const video = document.querySelector('video')
  * const tracker = trackHTML5Video('hero-video', video)
  * tracker.onUpdate((stats) => console.log(stats))
- * // Al desmontar:
+ * // On unmount:
  * tracker.stop()
  * ```
  */
 declare const trackHTML5Video: (videoId: string, videoElement: HTMLVideoElement) => VideoTrackerHandle;
 
 /**
- * LandingTracker — Orquestador de sesión completa
- * Inicializa y gestiona scroll tracking, click heatmap, section dwell time,
- * form auto-tracking y sesión start/end.
+ * LandingTracker — Full session orchestrator.
+ * Initializes and manages scroll tracking, click heatmap, section dwell time,
+ * form auto-tracking, and session start/end.
  * Framework-agnostic.
  */
 
@@ -613,30 +642,30 @@ declare class LandingTracker {
     private observers;
     private listeners;
     /**
-     * Inicializa el tracking de la landing con la configuración dada.
+     * Initializes landing page tracking with the given configuration.
      */
     init(config: LandingTrackerConfig): void;
     /**
-     * Destruye el tracker y limpia todos los observers y listeners.
+     * Destroys the tracker and cleans up all observers and listeners.
      */
     destroy(): void;
-    /** Trackear click en un CTA */
+    /** Track a CTA click */
     trackCTAClick(buttonName: string, section: string, additionalData?: Record<string, unknown>): void;
-    /** Trackear conversión */
+    /** Track a conversion */
     trackConversion(type: string, value?: number, additionalData?: Record<string, unknown>): void;
-    /** Trackear click en FAQs */
+    /** Track FAQ expansion */
     trackFAQExpand(question: string, index: number): void;
-    /** Trackear click social */
+    /** Track social link click */
     trackSocialClick(platform: string, action: string): void;
-    /** Trackear click en imagen */
+    /** Track image click */
     trackImageClick(imageName: string, section: string): void;
-    /** Trackear scroll a sección */
+    /** Track scroll to a section */
     trackScrollTo(section: string): void;
-    /** Trackear share */
+    /** Track content share */
     trackShare(platform: string, content: string): void;
-    /** Trackear descarga */
+    /** Track file download */
     trackDownload(fileName: string, fileType: string): void;
-    /** Obtener datos de la sesión actual */
+    /** Get current session data */
     getSessionData(): {
         duration: number;
         clicks: number;
@@ -655,7 +684,7 @@ declare class LandingTracker {
     private initClickHeatmap;
 }
 /**
- * Factory function para crear un LandingTracker.
+ * Factory function to create a LandingTracker.
  *
  * @example
  * ```ts
@@ -664,15 +693,15 @@ declare class LandingTracker {
  *   pageName: 'Kin Landing Page',
  *   gtmId: 'GTM-5GMQNFMN',
  * })
- * // Al desmontar:
+ * // On unmount:
  * tracker.destroy()
  * ```
  */
 declare const createLandingTracker: (config: LandingTrackerConfig) => LandingTracker;
 
 /**
- * API Client — Cliente HTTP configurable para persistencia al backend.
- * Framework-agnostic. Usa fetch nativo.
+ * API Client — Configurable HTTP client for backend persistence.
+ * Framework-agnostic. Uses native fetch.
  *
  * @example
  * ```ts
@@ -686,82 +715,81 @@ declare const createLandingTracker: (config: LandingTrackerConfig) => LandingTra
  */
 
 /**
- * Inicializa el cliente HTTP para la capa de persistencia.
- * Debe llamarse antes de usar funciones de lead submission, dwell time o queries.
+ * Initializes the HTTP client for the persistence layer.
+ * Must be called before using lead submission, dwell time, or query functions.
  */
 declare const initTrackingAPI: (config: TrackingAPIConfig) => void;
 /**
- * Verifica si el API client ha sido inicializado.
+ * Returns whether the API client has been initialized.
  */
 declare const isTrackingAPIInitialized: () => boolean;
 
 /**
- * Lead Submission — Creación y actualización de leads en el backend.
- * Migrado de lead-origin-detector.ts, framework-agnostic.
+ * Lead Submission — Lead creation and update against the backend.
+ * Migrated from lead-origin-detector.ts, framework-agnostic.
  */
 
 /**
- * Extrae todos los parámetros relevantes de la URL.
+ * Extracts all relevant parameters from the URL.
  *
- * @param url - URL opcional (si no se proporciona, usa window.location)
- * @returns Objeto con todos los parámetros extraídos
+ * @param url - Optional URL (defaults to window.location if omitted)
+ * @returns Object containing all extracted parameters
  */
 declare const extractUrlParams: (url?: string) => UrlParams;
 /**
- * Detecta el origen del lead basándose en los parámetros de la URL.
- * Facebook Ads: tiene fbclid O campaign_id
- * Orgánico: tiene whatsapp Y NO tiene fbclid Y NO tiene campaign_id
+ * Detects the lead origin based on URL parameters.
+ * Facebook Ads: has fbclid OR campaign_id
+ * Organic: has whatsapp AND does NOT have fbclid AND does NOT have campaign_id
  */
 declare const detectLeadOrigin: (url?: string) => LeadOrigin;
 /**
- * Construye el body de la petición según el tipo de origen.
+ * Builds the request body based on the lead origin type.
  */
 declare const buildTrackingRequestBody: (params: UrlParams, formData: LeadFormData, origin: LeadOrigin, options?: BuildRequestBodyOptions) => Record<string, unknown>;
 /**
- * Envía el lead al endpoint correcto según su origen.
+ * Submits the lead to the correct endpoint based on its origin.
  */
 declare const submitTrackingLead: (body: Record<string, unknown>, origin: LeadOrigin) => Promise<SubmitTrackingLeadResponse>;
 /**
- * Función completa: detecta origen, construye body y envía el lead.
+ * End-to-end function: detects origin, builds body, and submits the lead.
  *
  * @example
  * ```ts
  * const result = await submitLead(
  *   { nombre: 'Juan', correo: 'juan@mail.com', telefono: '+34600...' },
- *   { nameForm: 'Formulario Kin', videoCompleted: true },
+ *   { nameForm: 'Kin Form', videoCompleted: true },
  * );
  * ```
  */
 declare const submitLead: (formData: LeadFormData, options?: BuildRequestBodyOptions, url?: string) => Promise<SubmitTrackingLeadResponse>;
 /**
- * Actualiza un lead existente mediante PATCH.
+ * Updates an existing lead via PATCH.
  */
 declare const updateTrackingLead: (trackingId: number | string, updates: Record<string, unknown>) => Promise<boolean>;
 /**
- * Marca un lead como "WhatsApp enviado".
+ * Marks a lead as "WhatsApp sent".
  */
 declare const markWhatsAppSent: (leadId: number | string) => Promise<boolean>;
 /**
- * Construye un msgForm como JSON stringificado.
+ * Builds a msgForm as a JSON-stringified value.
  */
 declare const buildMsgFormJSON: (mensaje: string, datosAdicionales?: Record<string, unknown>) => string;
 
 /**
- * DwellTimeTracker — Tracking de tiempo de permanencia con envío periódico al backend.
- * Migrado de dwell-time.ts (~960 líneas → ~280 líneas limpias).
+ * DwellTimeTracker — Dwell time tracking with periodic backend reporting.
+ * Migrated from dwell-time.ts (~960 lines -> ~280 clean lines).
  * Framework-agnostic.
  */
 
 /**
- * Clase que mide el tiempo de permanencia del usuario en una página
- * y lo envía periódicamente al backend de tracking.
+ * Measures user dwell time on a page and periodically sends it to the tracking backend.
  *
- * Características:
- * - Envío automático cada 30 segundos
- * - Pausa automática cuando la pestaña se oculta
- * - sendBeacon en beforeunload para máxima confiabilidad
- * - Retry de updates pendientes via sessionStorage
- * - Tracking de video integrado (videoTimeWatched, videoCompleted)
+ * Features:
+ * - Automatic send every 30 seconds
+ * - Auto-pause when tab is hidden
+ * - sendBeacon on beforeunload for maximum reliability
+ * - Retry pending updates via sessionStorage
+ * - Integrated video tracking (videoTimeWatched, videoCompleted)
  */
 declare class DwellTimeTracker {
     private startTime;
@@ -782,28 +810,28 @@ declare class DwellTimeTracker {
     private boundVisibilityChange;
     constructor();
     /**
-     * Inicia el tracking del tiempo de permanencia.
+     * Starts dwell time tracking.
      */
     start(config: DwellTimeConfig): void;
     /**
-     * Detiene el tracking y envía el tiempo acumulado.
+     * Stops tracking and sends accumulated time.
      */
     stop(): void;
     /**
-     * Obtiene el tiempo transcurrido en segundos (restando tiempo pausado).
+     * Returns elapsed time in seconds (excluding paused time).
      */
     getElapsedTime(): number;
     /**
-     * Actualiza manualmente el tiempo del video.
-     * Llamar desde el VideoTracker u otros adaptadores.
+     * Manually updates video time.
+     * Called from VideoTracker or other adapters.
      */
     updateVideoTime(videoTimeWatched: number, videoCompleted?: boolean): void;
     /**
-     * Actualiza el trackingDataId (útil cuando se obtiene después del registro).
+     * Updates the trackingDataId (useful when obtained after registration).
      */
     updateTrackingId(trackingDataId: number | string): void;
     /**
-     * Limpia todos los listeners y timers.
+     * Cleans up all listeners and timers.
      */
     destroy(): void;
     private checkLocalStorageForId;
@@ -819,22 +847,22 @@ declare class DwellTimeTracker {
 }
 declare const dwellTimeTracker: DwellTimeTracker;
 /**
- * Inicia el tracking del tiempo de permanencia.
+ * Starts dwell time tracking.
  */
 declare const startDwellTimeTracking: (config: DwellTimeConfig) => void;
 /**
- * Detiene el tracking y envía el tiempo acumulado.
+ * Stops tracking and sends accumulated time.
  */
 declare const stopDwellTimeTracking: () => void;
 
 /**
- * Tracking Queries — Consultas GET al backend de tracking.
- * Migrado de TrackingService.ts y LeadTrackingService.ts.
+ * Tracking Queries — GET queries to the tracking backend.
+ * Migrated from TrackingService.ts and LeadTrackingService.ts.
  * Framework-agnostic.
  */
 
 /**
- * Obtiene los datos de un tracking lead por su ID.
+ * Retrieves tracking lead data by its ID.
  *
  * @example
  * ```ts
@@ -844,8 +872,8 @@ declare const stopDwellTimeTracking: () => void;
  */
 declare const getTrackingById: (trackingId: number | string) => Promise<TrackingLead>;
 /**
- * Obtiene un lead con sus datos de tracking asociados.
- * Procesa la respuesta para extraer videoVisto, tiempoReproducido, etc.
+ * Retrieves a lead with its associated tracking data.
+ * Processes the response to extract videoVisto, tiempoReproducido, etc.
  *
  * @example
  * ```ts
@@ -855,15 +883,15 @@ declare const getTrackingById: (trackingId: number | string) => Promise<Tracking
  */
 declare const getLeadWithTracking: (leadId: string) => Promise<LeadTrackingData>;
 /**
- * Genera un link de tracking para un funnel.
+ * Generates a tracking link for a funnel.
  *
  * @example
  * ```ts
- * const { link } = await generateTrackingLink(1, 'mi-dominio.com');
+ * const { link } = await generateTrackingLink(1, 'my-domain.com');
  * ```
  */
 declare const generateTrackingLink: (funnelId: number, customDomain: string) => Promise<{
     link: string;
 }>;
 
-export { type BuildRequestBodyOptions, type ClickData, type DwellTimeConfig, DwellTimeTracker, LandingTracker, type LandingTrackerConfig, type LeadFormData, type LeadOrigin, type LeadTrackingData, type SessionSummary, type SubmitTrackingLeadResponse, type TrackingAPIConfig, type TrackingConfig, type TrackingEventData, type TrackingLead, type TrackingLeadResponse, type UTMParams, type UrlParams, type UseVideoTrackingOptions, type VideoStats, VideoTracker, type VideoTrackerHandle, type VideoTrackingState, type VideoUpdateCallback, type VisitorData, buildMsgFormJSON, buildTrackingRequestBody, captureUTMParams, captureUserIdFromURL, createLandingTracker, detectLeadOrigin, dwellTimeTracker, extractUrlParams, generateTrackingLink, getGATrackingId, getLeadWithTracking, getTrackingById, getUserId, getUserName, initGA, initTrackingAPI, injectGTMScript, isGAInitialized, isTrackingAPIInitialized, markWhatsAppSent, pushToDataLayer, reinitGA, resetAnalytics, setUserId, setUserName, startDwellTimeTracking, stopDwellTimeTracking, submitLead, submitTrackingLead, trackCTAClick, trackContactClick, trackConversion, trackDownload, trackEvent, trackFAQExpand, trackFormFieldComplete, trackFormStart, trackFormSubmit, trackFormValidationError, trackHTML5Video, trackImageClick, trackPageView, trackPricingCardClick, trackScrollTo, trackSectionClick, trackShare, trackSocialClick, trackTimeInSection, trackVoomlyByEmbedId, trackWistiaByMediaId, updateTrackingLead, videoTracker };
+export { type BuildRequestBodyOptions, type ClickData, type DwellTimeConfig, DwellTimeTracker, LandingTracker, type LandingTrackerConfig, type LeadFormData, type LeadOrigin, type LeadTrackingData, type SessionSummary, type SubmitTrackingLeadResponse, type TrackingAPIConfig, type TrackingConfig, type TrackingEventData, type TrackingLead, type TrackingLeadResponse, type UTMParams, type UrlParams, type UseVideoTrackingOptions, type VideoStats, VideoTracker, type VideoTrackerHandle, type VideoTrackingState, type VideoUpdateCallback, type VisitorData, buildMsgFormJSON, buildTrackingRequestBody, captureUTMParams, captureUserIdFromURL, createLandingTracker, detectLeadOrigin, dwellTimeTracker, extractUrlParams, generateTrackingLink, getGATrackingId, getLeadWithTracking, getTrackingById, getUserId, getUserName, initGA, initTrackingAPI, injectGTMScript, isGAInitialized, isTrackingAPIInitialized, markWhatsAppSent, pushToDataLayer, reinitGA, resetAnalytics, setUserId, setUserName, startDwellTimeTracking, stopDwellTimeTracking, submitLead, submitTrackingLead, trackCTAClick, trackContactClick, trackConversion, trackDownload, trackEvent, trackFAQExpand, trackFormFieldComplete, trackFormStart, trackFormSubmit, trackFormValidationError, trackHTML5Video, trackImageClick, trackPageView, trackPricingCardClick, trackQuizAnswer, trackQuizComplete, trackQuizStart, trackScrollTo, trackSectionClick, trackShare, trackSocialClick, trackThankYouPageVisit, trackTimeInSection, trackVoomlyByEmbedId, trackWhatsAppClick, trackWistiaByMediaId, updateTrackingLead, videoTracker };